package cn.nju.seg.atg.util;

import java.io.BufferedReader;
import java.io.FileReader;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

import cn.nju.seg.atg.GA.CrossoverModel;
import cn.nju.seg.atg.GA.StringGA;
import cn.nju.seg.atg.model.SimpleCFGNode;
import cn.nju.seg.atg.parse.Builder;
/**
 *  模拟退火算法，参考文献：Data Generation for Path Testing   (Software Quality Journal,12,121-136,2004)
 *  by OJS
 */
public class SimuAnneal{

	/**
	 * 输入变量（形式参数）个数
	 */
	private static int inputCount = 4;     // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>可以改变<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	
	/**
	 * 辅助变量的个数，辅助变量是这样的变量，对判断分支中含不等符号的语句引入新变量，使之成为等式，例如引入辅助变量x，使  if（ n>3） 转化为  if（n-3 = x）
	 */
	private static int auxilaryCount = 10;   // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>可以改变<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	/*     
	    for isLeapYear: 3  
	         triangle : 17
	         expint : 20
	          bessj : 15
	          julday:7
	          plgndr: 14
	          ei:12
	          caldat:12
	          icrc:10
	 */
	
	/**
	 * 退火开始时的温度
	 */
	private static double t0 ; 
	
	/**
	 * 冰点温度（退火结束时的温度）
	 */
	private static double tf ; 
	
	/**
	 * 中间状态温度
	 */
	private static double t  ; 
	
	/**
	 *  扰动过程中改变的变量（可能是输入变量（即行参），也可能是辅助变量）
	 */
	private static int changeVari;
	
	/**
	 *  扰动过程中改变的位
	 */
	private static int changeBit;
	
	/**
	 *  是否接受扰动                        
     */
	private static boolean flag;
	
	/**
	 *  测试路径
	 */
	private static CFGPath tpath;
	
	/**
	 *  输入变量的二进制表示位数
	 */
	private static int len;        //          >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>可以改变，但必须 >=4,最好是偶数<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<   
	
	
	/**
	 * 当变量涉及浮点类型时，其二进制表示小数点左右两边的位数 
	 */
	private static int leftSideLen,rightSideLen;
	
	/**
	 *  (Li,Ri)的二进制表示长度，计算能源函数时用到 
	 */
	private static int length;       // 二进制表示数组长度
	
	
	/**
	 *  (Li,Ri)的二进制表示小数点左右两边的长度，计算能源函数时用到 
	 */
	private static int leftSideLength ,rightSideLength;
	
	/**
	 *  参数类型指标
	 */
	private static boolean isIntType = true;     //        >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>可以改变<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 
	
	/**
	 * for test      
	 *   
	 */
	private static double maximalE;
	
	/**
	 *  对变量所做的限制,集合中的变量必须是正数
	 */
	private static Set<Integer> positiveSet;
	
	/**
	 *  对变量所做的限制,集合中的变量必须是负数
	 */
	private static Set<Integer> negativeSet;
	
	/**
	 *  对变量所做的限制,集合中的变量必须是非负
	 */
	private static Set<Integer> unNegativeSet;
	
	/**
	 * 对变量所做的限制,集合中的变量必须是非正
	 */
	private static Set<Integer> unPositiveSet;
	
	/**
	 *  对变量所做的限制，集合中的变量必须非0
	 */
	private static Set<Integer> unZeroSet;
	
	/**
	 *  扰动变量范围集合
	 */
	private static Set<Integer> perturRangeSet;
	
	/**
	 *  必须是整型的变量集合，（针对混合型行参）
	 */
	private static Set<Integer> intSet;
	
	/**
	 *  已经计算过能源函数值的节点集合（用于辨别有不同能源函数值的for结点）
	 */
	private static List<String> finishCalNodeSet;
	
	/**
	 *  路径经过的节点名集合
	 */
	private static List<String> nodeSetInPath;
	
	/**
	 *  路径节点的能源函数值集合
	 */
	private static List<Double> nodeEnergyValueSetInPath;
	
	/**
	 *  与路径变量关联的节点号集合
	 */
	private static int[][] nodeSetCorrectedWithVari;
	
	/**
	 *  路径节点能源函数值变化量
	 */
	private static List<Double> tempNodeEnergyValueSetInPath;
	
	/**
	 *  for test
	 */
	private static double ss;
	
	/* 当函数行参为整数类型时，模拟退火所用到的变量如下定义       */
	
	/**
	 * 整型行参的二进制表示数组,用数组表示输入变量的二进制表示，如[1,0,0,1,0,0,1,0]表示二进制数(反码） 10010010
	 */
	private static List<int[]> inputBits;  
	
	/**
	 * 辅助变量的二进制表示数组，与inputBits类似
	 */
	private static List<int[]> auxilaryBits;
	
	/**
	 * 能源函数值（针对整型行参）
	 */
	private static double energyValue;	
	
	/**
	 * 在临时配置下的能源函数值（针对整型行参）
	 */
	private static double tempEnergyValue;
	
	/**
	 * 目前取得的最小能源函数值 （针对整型行参）
	 */
	private static double minimalEnergyValue;
	
	/**
	 * test
	 */
	private static List<int[]> mInputBits;
	
	/**
	 * test
	 */
	private static List<Long> mAuxilaryValue;
	
	/**
	 * 最小能源函数值对应的配置（针对整型行参）
	 */
	private static List<Long> mInputValue;
	
	/**
	 * 整型行参的值
	 */
	private static List<Long> inputValue;
	
	/**
	 * 整型辅助变量的值
	 */
	private static List<Long> auxilaryValue;
	
	/**3
	 * 每次扰动产生的临时配置 (针对整型行参）
	 */
	private static List<Long> tempInputValue , tempAuxilaryValue;
	
	/**
	 * 每次扰动产生的临时配置的二进制表示数组 (针对整型行参）
	 */
	private static List<int[]> tempInputBits , tempAuxilaryBits;
	
	
	
	/* 当函数行参为浮点类型或混合类型（既有整数类型，又有浮点类型）时，模拟退火所用到的变量如下定义       */
	
	/**
	 * 浮点型或混合型行参的二进制表示数组,用数组表示输入变量的二进制表示，如[1,0,0,1,0,0,1,0,  1,0,0,1,0,1,0,0]表示二进制数（反码） 10010010.10010100
	 */
	private static List<int[]> inputBits2;  
	
	/**
	 * 辅助变量的二进制表示数组，与inputBits2类似
	 */
	private static List<int[]> auxilaryBits2;
	
	/**
	 * 能源函数值 (针对浮点型或混合型行参）
	 */
	private static double energyValue2;
	
	/**
	 * 在临时配置下的能源函数值（针对浮点型或混合型行参）
	 */
	private static double tempEnergyValue2;
	
	/**
	 * 目前取得的最小能源函数值 （针对浮点型和混合型行参）
	 */
	private static double minimalEnergyValue2;
	
	/**
	 * 最小能源函数值对应的配置（针对浮点型或混合型行参）
	 */
	private static List<Double> mInputValue2;
	
	/**
	 * 浮点型或混合型行参的值
	 */
	private static List<Double> inputValue2;
	
	/**
	 * 浮点型辅助变量的值
	 */
	private static List<Double> auxilaryValue2;
	
	/**
	 * 每次扰动产生的临时配置(针对浮点型或混合型行参）
	 */
	private static List<Double> tempInputValue2,tempAuxilaryValue2;
	
	/**
	 * 每次扰动产生的临时配置的二进制表示数组 (针对浮点型或混合型行参）
	 */
	private static List<int[]> tempInputBits2 , tempAuxilaryBits2;
	
	/**
	 * test
	 */
	private static List<Double> mAuxilaryValue2;
	
	/**
	 * test
	 */
	private static List<int[]> mAuxilaryBits2;
	
	
	/*   *****************************************               成员方法            **************************************** */
	
	
	/**
	 * 为测试路径生成测试用例
	 * @param path
	 * @return
	 */
	public static int generateTestData(CFGPath path){ 
		/*  覆盖路径指标，-1表示未覆盖测试路径    */
		int isCovered = -1;  
//		ss =0;                   // for test
		initialTargetPath(path);   // 初始化目标路径
		initialLens(path);             // 初始化长度
		flag = true;
		
		if(isIntType == true)  // 行参类型为 整型
		{
			isCovered = generateTestDataForInt(path);
		}
		else  // 行参类型为浮点型或混合型
		{
			isCovered = generateTestDataForOther(path);
		}
		return isCovered;
	}
	
	
	/**
	 * 为测试路径生成测试用例(针对整型行参）
	 * @param pathIndex
	 * @return
	 */
	public static int generateTestDataForInt(CFGPath path){ 
		
		/*  覆盖路径指标，-1表示未覆盖测试路径    */
		int isCovered = -1;    
		
		/* 计算总变量数目                         */
		int N = inputCount + auxilaryCount;
		
		/* 初始化              */
		initialConstraintSet();  // 初始化参数限制集
		initialPerturRangeSet(path); //初始化扰动变量范围集
		initialConfiguration();     // 初始化参数配置
	    initialTempConfiguration(); // 初始化临时配置
	    initialMiniConfiguration(); // 初始化最小配置
	    nodeSetCorrectedWithVari = null;
	    nodeSetCorrectedWithVari = setNodeSetCorrectedWithVari();  // 设置与变量相关的节点号集合
	    initialNodeInforInPath(path);    // 初始化路径节点信息（节点名，节点能源函数值）
	    energyValue = calEnergyValue(path); // 初始化能源函数值  
	    minimalEnergyValue = energyValue; // 初始化最小能源函数值
	    
	    /* 确定初始温度和冰点温度     */
		t0 = determineT0();               
		tf = determineTf();   
		
		/* 确定起始温度       */
		t = t0;
		
		/* 记录最小配置保持不变过程中经历的温度改变的次数      */
		int k = 0;
		
		/* 记录循环次数                                   */
		int times=0;
		
		/* 扰动会路径能源函数值改变量      */
//		double deta = 0;
		
		
		/* 模拟退火过程                                  */
		while( t>tf || k<50)
		{
			for(int i=1,size=10*N*len;i<=size;i++)   // for test
			{
				times++;
				perturbation();
				tempEnergyValue = calTempEnergyValue(path);    //  计算路径在临时配置下的能源函数值
				
//				if(maximalE < tempEnergyValue)
//				{
//					maximalE = tempEnergyValue;
//				}
				
				flag = acceptPerturbation();
				if(flag == true)
				{
					updateConfiguration();             // 更新配置
					updateNodeEnergyValueSetInPath();    // 更新路径节点能源函数值
					energyValue = tempEnergyValue;      // 更新能源函数值
					
					/*  更新最小配置和最小能源函数值   */
					if(tempEnergyValue < minimalEnergyValue)
					{
//						System.out.println("最小能源值发生改变： "+times);
						minimalEnergyValue  = tempEnergyValue;
						updateMiniConfiguration();  
						k=0;     // 最小配置发生改变， k值重新置0
						if(minimalEnergyValue == 0)break;
					}
				}
			}
			if(minimalEnergyValue == 0)break;
			t = 0.95 * t;
			k++;
		}
		System.out.println("times= "+times);
		Builder.consoleStream.println("times= "+times);
		
		
		// for test
		System.out.println("minimalEnergyValue= "+minimalEnergyValue);
		System.out.println("miniConfigurtion = ");
//		for(int i=0;i<mInputValue.size();i++)
//		{
//			System.out.print("x"+(i+1)+"= "+mInputValue.get(i)+" ");
//		}
//		System.out.println();
		for(int i=0;i<mAuxilaryValue.size();i++)
		{
			if(!perturRangeSet.contains(new Integer(inputCount+i+1)))continue;
			System.out.print("au"+(i+1)+"= "+mAuxilaryValue.get(i)+" ");
		}
		System.out.println();
		
		/* 执行待测试函数，生成中间文件            */
		callFunction();
		
		/* 生成中间文件的路径                    */
//		String pathFile = "/home/feiniao/atg_data/IsLeapYear.dat";
//		String pathFile = "/home/feiniao/atg_data/julday.dat";
//		String pathFile = "/home/feiniao/atg_data/caldat.dat";
//		String pathFile = "/home/feiniao/atg_data/Triangle.dat";
		String pathFile = "/home/feiniao/atg_data/icrc.dat";

		/* 从中间文件读执行到的节点名称集合，如  node1,node2,node8,node9    */
		List<String> snoList = readPathFromFile(pathFile);
		System.out.println("this path is "+snoList.toString());
		Builder.consoleStream.println("this path is "+snoList.toString());
		
		/* 判断是否运行了目标路径，并更新isCovered      */
		if(isTargetPath(path,snoList))
		{
			isCovered = 0;
		}
		
		/* 输出运行结果                        */
		if(isCovered == 0)
		{
			/* for isLeapYear    */
//			System.out.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
 
			/* for triangle      */
//			System.out.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
//			Builder.consoleStream.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
			
//			/* for julday    */
//			System.out.println("找到可用输入：\n"+" mm= "+mInputValue.get(0).intValue()+" id= "+mInputValue.get(1).intValue()+" iyyy= "+mInputValue.get(2).intValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" mm= "+mInputValue.get(0).intValue()+" id= "+mInputValue.get(1).intValue()+" iyyy= "+mInputValue.get(2).intValue());
			
			/* for caldat    */
//			System.out.println("找到可用输入：\n"+" julian= "+mInputValue.get(0).intValue()+" mm= "+mInputValue.get(1).intValue()+" id= "+mInputValue.get(2)+" iyyy= "+mInputValue.get(3));
//			Builder.consoleStream.println("找到可用输入：\n"+" julian= "+mInputValue.get(0).intValue()+" mm= "+mInputValue.get(1).intValue()+" id= "+mInputValue.get(2)+" iyyy= "+mInputValue.get(3));
			
			/* for icrc */
			System.out.println("找到可用输入：\n"+" crc= "+mInputValue.get(0).shortValue()+" len= "+mInputValue.get(1).longValue()+" jinit= "+mInputValue.get(2).shortValue()+" jrev= "+mInputValue.get(3).intValue());
			Builder.consoleStream.println("找到可用输入：\n"+" crc= "+mInputValue.get(0).shortValue()+" len= "+mInputValue.get(1).longValue()+" jinit= "+mInputValue.get(2).shortValue()+" jrev= "+mInputValue.get(3).intValue());
		}
		else
		{
			/* for isLeapYear    */
//			System.out.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
			
			/* for triangle      */
//			System.out.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
//			Builder.consoleStream.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
			
			/* for julday    */
//			System.out.println("未找到可用输入：\n"+" mm= "+mInputValue.get(0).intValue()+" id= "+mInputValue.get(1).intValue()+" iyyy= "+mInputValue.get(2).intValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" mm= "+mInputValue.get(0).intValue()+" id= "+mInputValue.get(1).intValue()+" iyyy= "+mInputValue.get(2).intValue());
			
			/* for caldat    */
//			System.out.println("未找到可用输入：\n"+" julian= "+mInputValue.get(0).intValue()+" mm= "+mInputValue.get(1).intValue()+" id= "+mInputValue.get(2)+" iyyy= "+mInputValue.get(3).intValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" julian= "+mInputValue.get(0).intValue()+" mm= "+mInputValue.get(1).intValue()+" id= "+mInputValue.get(2)+" iyyy= "+mInputValue.get(3).intValue());
			
			/* for icrc */
			System.out.println("未找到可用输入：\n"+" crc= "+mInputValue.get(0).shortValue()+" len= "+mInputValue.get(1).longValue()+" jinit= "+mInputValue.get(2).shortValue()+" jrev= "+mInputValue.get(3).intValue());
			Builder.consoleStream.println("未找到可用输入：\n"+" crc= "+mInputValue.get(0).shortValue()+" len= "+mInputValue.get(1).longValue()+" jinit= "+mInputValue.get(2).shortValue()+" jrev= "+mInputValue.get(3).intValue());
		}
		return isCovered;
	}
	
	
	/**
	 * 为测试路径生成测试用例(针对浮点型或混合型行参）
	 * @param pathIndex
	 * @return
	 */
	public static int generateTestDataForOther(CFGPath path){  
		 
		/*  覆盖路径指标，-1表示未覆盖测试路径    */
		int isCovered = -1;    
		
		/* 计算总变量数目                         */
		int N = inputCount + auxilaryCount;
		
		/* 初始化              */
		initialConstraintSet();  // 初始化参数限制集
		initialPerturRangeSet(path); //初始化扰动变量范围集
		initialIntSet();      // 初始化整型变量集
		initialConfiguration2();     // 初始化参数配置
	    initialTempConfiguration2(); // 初始化临时配置
	    initialMiniConfiguration2(); // 初始化最小配置
	    nodeSetCorrectedWithVari = setNodeSetCorrectedWithVari();  // 设置与变量相关的节点号集合
	    initialNodeInforInPath2(path);    // 初始化路径节点信息（节点名，节点能源函数值）
	    energyValue2 = calEnergyValue2(path); // 初始化能源函数值  	   
	    minimalEnergyValue2 = energyValue2; // 初始化最小能源函数值
	    
//	    searchDetaRange(path);  // for test 
	    
	    /* 确定初始温度和冰点温度     */
		t0 = determineT0();               
		tf = determineTf();   
		
		/* 确定起始温度       */
		t = t0;
		
		/* 记录最小配置保持不变过程中经历的温度改变的次数      */
		int k = 0;
		
		/* 记录循环次数                                   */
		int times=0;
		
		/* 扰动路径能源函数值改变量      */
		double deta = 0;
		
//		/* 初始化最近一次扰动接受指标， 扰动变量， 扰动位                   */
//		flag = false;
//		changeVari = -1;       
//		changeBit = -1;     
		
		/* 模拟退火过程                                  */
		while( t>tf || k<50)
		{
			for(int i=1,size=10*N*len;i<=size;i++)  
			{
				times++;
				perturbation2();                                //配置扰动
				tempEnergyValue2 = calTempEnergyValue2(path);    //  计算路径在临时配置下的能源函数值
				
				flag = acceptPerturbation2();
				if(flag == true)
				{
					updateConfiguration2();             // 更新配置
					updateNodeEnergyValueSetInPath();    // 更新路径节点能源函数值
					energyValue2 = tempEnergyValue2;      // 更新能源函数值
					
					/*  更新最小配置和最小能源函数值   */
					if(tempEnergyValue2 < minimalEnergyValue2 || Double.isNaN(minimalEnergyValue2))
					{
						minimalEnergyValue2  = tempEnergyValue2;
						updateMiniConfiguration2();  
						k=0;     // 最小配置发生改变， k值重新置0
						if(minimalEnergyValue2 == 0)break;
					}
				}
			}
			if(minimalEnergyValue2 == 0)break;
			t = 0.95 * t;
			k++;
		}
		System.out.println("times= "+times);
		Builder.consoleStream.println("times= "+times);
		
		// for test
		System.out.print("miniConfigurtion = ");
		for(int i=0;i<mInputValue2.size();i++)
		{
			System.out.print("x"+(i+1)+"= "+mInputValue2.get(i)+" ");
		}
		for(int i=0,siz=mAuxilaryValue2.size();i<siz;i++)
		{
//			Integer in = new Integer(i+1+inputCount);
////			if(!perturRangeSet.contains(new Integer(inputCount+i+1)))continue;
//			if((positiveSet.contains(in) && mAuxilaryValue2.get(i).doubleValue()<= 0) ||
//					(unPositiveSet.contains(in) && mAuxilaryValue2.get(i).doubleValue()> 0) ||
//							(negativeSet.contains(in) && mAuxilaryValue2.get(i).doubleValue()>= 0) ||
//									(unNegativeSet.contains(in) && mAuxilaryValue2.get(i).doubleValue()< 0) ||
//											(unZeroSet.contains(in) && mAuxilaryValue2.get(i).doubleValue()== 0) )
//			{
//				System.out.println("\n！！！出错了！！！au"+(i+1)+"= "+mAuxilaryValue2.get(i)+" ");
//				System.out.println();
//			}
//			else
			{
				System.out.print("au"+(i+1)+"= "+mAuxilaryValue2.get(i)+" ");
			}
		}
		System.out.println();
		System.out.println("minimalEnergyValue2= "+minimalEnergyValue2);
//		System.out.println();
		
		/* 执行待测试函数，生成中间文件            */
		callFunction();
		
		/* 生成中间文件的路径                    */
//		String pathFile = "/home/feiniao/atg_data/IsLeapYear.dat";
//		String pathFile = "/home/feiniao/atg_data/Triangle.dat";
//		String pathFile = "/home/feiniao/atg_data/expint.dat";
//		String pathFile = "/home/feiniao/atg_data/plgndr.dat";
//		String pathFile = "/home/feiniao/atg_data/bessj.dat";
		String pathFile = "/home/feiniao/atg_data/ei.dat";

		/* 从中间文件读执行到的节点名称集合，如  node1,node2,node8,node9    */
		List<String> snoList = readPathFromFile(pathFile);
		System.out.println(/*"this path is "+*/snoList.toString());
		Builder.consoleStream.println("this path is "+snoList.toString());
		
		/* 判断是否运行了目标路径，并更新isCovered      */
		if(isTargetPath(path,snoList))
		{
			isCovered = 0;
		}
		
		/* 输出运行结果                        */
		if(isCovered == 0)
		{
			/* for isLeapYear    */
//			System.out.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
 
			/* for triangle      */
//			System.out.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
//			Builder.consoleStream.println("找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
			
			/* for expint       */
//			System.out.println("找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
		
			/* for plgndr      */
//			System.out.println("找到可用输入：\n"+" l= "+mInputValue2.get(0).intValue()+" m= "+mInputValue2.get(1).intValue()+" x= "+mInputValue2.get(2).doubleValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" l= "+mInputValue2.get(0).intValue()+" m= "+mInputValue2.get(1).intValue()+" x= "+mInputValue2.get(2).doubleValue());
			
			/* for ei    */
			System.out.println("找到可用输入：\n"+" x= "+mInputValue2.get(0).doubleValue());
			Builder.consoleStream.println("找到可用输入：\n"+" x= "+mInputValue2.get(0).doubleValue());
			
			/* for bessj  */
//			System.out.println("找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
//			Builder.consoleStream.println("找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
		}
		else
		{
			/* for isLeapYear    */
//			System.out.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue());
			
			/* for triangle      */
//			System.out.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
//			Builder.consoleStream.println("未找到可用输入：\n"+" a= "+mInputValue.get(0).intValue()+" b= "+mInputValue.get(1)+" c= "+mInputValue.get(2));
			
			/* for expint       */
//			System.out.println("未找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
			
			/* for plgndr      */
//			System.out.println("未找到可用输入：\n"+" l= "+mInputValue2.get(0).intValue()+" m= "+mInputValue2.get(1).intValue()+" x= "+mInputValue2.get(2).doubleValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" l= "+mInputValue2.get(0).intValue()+" m= "+mInputValue2.get(1).intValue()+" x= "+mInputValue2.get(2).doubleValue());
			
			/* for ei    */
			System.out.println("未找到可用输入：\n"+" x= "+mInputValue2.get(0).doubleValue());
			Builder.consoleStream.println("未找到可用输入：\n"+" x= "+mInputValue2.get(0).doubleValue());
			
			/* for bessj       */
//			System.out.println("未找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
//			Builder.consoleStream.println("未找到可用输入：\n"+" n= "+mInputValue2.get(0).intValue()+" x= "+mInputValue2.get(1).doubleValue());
		}
		return isCovered;
	}
	
	
	/**
	 *  供测试用，寻找初次扰动能源函数值的变化范围
	 */
	private static void searchDetaRange(CFGPath path)
	{
		double detaup=0;
		double detadown =Math.pow(2, leftSideLength);
		double e0,e1;
		initialConstraintSet();  // 初始化参数限制集
		initialPerturRangeSet(path); //初始化扰动变量范围集
		initialIntSet();      // 初始化整型变量集
		for(int i=0;i<1000000;i++)
		{
			initialConfiguration2();     // 初始化参数配置
		    initialTempConfiguration2(); // 初始化临时配置
		    nodeSetCorrectedWithVari = setNodeSetCorrectedWithVari();  // 设置与变量相关的节点号集合
		    initialNodeInforInPath2(path);    // 初始化路径节点信息（节点名，节点能源函数值）
		    e0 = calEnergyValue2(path); // 初始化能源函数值  	   
			perturbation2();
			e1 = calTempEnergyValue2(path);
			if(e1>e0)			
			{
				if(detaup<e1-e0)
				{
					detaup = e1-e0;
				}
				if(detadown>e1-e0)
				{
					detadown = e1-e0;
				}
			}
		}
		System.out.println("detaup= "+detaup);
		System.out.println("detadown= "+detadown);
	}
	
	/**
	 *  初始化目标路径
	 */
	private static void initialTargetPath(CFGPath path)
	{
		tpath = path;
	}
	
	/**
	 *  初始化长度
	 */
	private static void initialLens(CFGPath path)
	{
	/**  len:
	 *  
	    isLeapYear: 16
	    triangle: 8
	    expint : 27+52
	    bessj : 5+510
	    julday: 12
	    plgndr: 9+7
	    ei: 38+745
	    caldat: 17
	 */
		
		
		/**  length:
		 * 
		    isLeapYear: 16
		    triangle:24
		    expint: 27+52
		    bessj : 9+1020
		    julday: 21
		    plgndr: 11+9
		    ei:  60+60
		    caldat: 23
		 */
		List<SimpleCFGNode> snoList = path.getPath();
		List<String> snoNameList = new ArrayList<String>();
		for(int i=0,size=snoList.size();i<size;i++)
		{
			snoNameList.add(snoList.get(i).getName());
		}
		
		/**
		 *  for bessj
		 */
//		if(!snoNameList.contains("node16"))
//		{
//			leftSideLen = 5;
//			rightSideLen = 6;
//			
//			leftSideLength = 11;
//			rightSideLength = 12;
//		}
//		else
//		{
//			leftSideLen = 5;
//			rightSideLen = 510;
//			
//			leftSideLength = 9;
//			rightSideLength = 1020;
//		}
		/**
		 *  for expint
		 */
//		if(snoNameList.contains("node13"))
//		{
//			leftSideLen = 27;
//			rightSideLen = 1;
//			
//			leftSideLength = 27;
//			rightSideLength = 1;
//		}
//		else if(snoNameList.contains("node19") && snoNameList.contains("node26"))
//		{
//			leftSideLen = 4;
//			rightSideLen = 52;
//			
//			leftSideLength = 5;
//			rightSideLength = 52;
//		}
//		else if(snoNameList.contains("node19")&& snoNameList.contains("node26"))
//		{
//			leftSideLen = 4;
//			rightSideLen = 29;
//			
//			leftSideLength = 5;
//			rightSideLength = 29;
//		}
//		else
//		{
//			leftSideLen = 4;
//			rightSideLen = 3;
//			
//			leftSideLength = 5;
//			rightSideLength = 3;
//		}
		
		/**
		 *  for ei
		 */
//		if(snoNameList.contains("node5") )
//		{
//			leftSideLen = 3;
//			rightSideLen = 980;
//			
//			leftSideLength = 4;
//			rightSideLength = 10;
//		}
//		else if(snoNameList.contains("node15") && !snoNameList.contains("node19"))
//		{
//			leftSideLen = 7;
//			rightSideLen = 3;
//			
//			leftSideLength = 7;
//			rightSideLength = 8; 
//		}
//		else if(snoNameList.contains("node15") && snoNameList.contains("node19"))
//		{
//			leftSideLen = 54;
//			rightSideLen = 1;
//			
//			leftSideLength = 55;
//			rightSideLength = 2;
//		}
//		else
//		{
//			leftSideLen = 7;
//			rightSideLen = 3;
//			
//			leftSideLength = 7;
//			rightSideLength = 8; 
//		}
		
		/**
		 * for julday
		 */
//		if(!snoNameList.contains("node11"))
//		{
//			leftSideLen  = 4;
//			leftSideLength = 21;
//		}
//		else if(snoNameList.contains("node3") && snoNameList.contains("node7"))
//		{
//			leftSideLen = 16;
//			leftSideLength = 26;
//		}
//		else if( snoNameList.contains("node3") && snoNameList.contains("node8"))
//		{
//			leftSideLen = 22;
//			leftSideLength =31;
//		}
//		else if(snoNameList.contains("node5") && snoNameList.contains("node7"))
//		{
//			leftSideLen = 17;
//			leftSideLength =27;
//		}
//		else if( snoNameList.contains("node5") && snoNameList.contains("node8"))
//		{
//			leftSideLen = 22;
//			leftSideLength =31;
//		}
//		else
//		{
//			leftSideLen = 12;
//			leftSideLength =23;
//		}
		
		/**
		 *  for icrc
		 */
		{
			leftSideLen = 3;
			leftSideLength = 4;
		}
		
		
		/**
		 *  general 
		 */
		if(isIntType == true)
		{
			len = leftSideLen;
			length = leftSideLength;  // 取值不该超过63
		}
		else
		{
			len = leftSideLen +rightSideLen;
			length = leftSideLength + rightSideLength; 
		}
	}
	
	
	
	/**
	 *  初始化配置(适用于整型输入变量）
	 */
	private static void initialConfiguration(){  
		
		
		inputBits = new ArrayList<int[]>();
		auxilaryBits = new ArrayList<int[]>();
		inputValue = new ArrayList<Long>();
		auxilaryValue = new ArrayList<Long>();
		int exp = 1<<(len-2);
		Random rd = new Random();
		
		/* 为inputBits的每一个元素数组的每一位随即设为0或1，分配完毕后，计算对应的inputValue中元素的值   */
		for(int i=0;i<inputCount;i++)
		{
			int tempValue = 0;
			int[] temp = new int[len];
			Integer in = new Integer(i+1);
			int tempExp = exp;
			/* 为非符号位赋值，注意当变量属于非零限制集合时的处理   */
			for(int j=1;j<len;j++)
			{
				if(Math.random()>=0.5)
				{
					temp[j]=1;
					tempValue += tempExp;
				}
				tempExp >>=1;
			}
			if(tempValue == 0 && ( unZeroSet.contains(in) ||
			        positiveSet.contains(in) ||
			        negativeSet.contains(in)) )  // 此时将整数部分某一非符号位置1
			{
				int alterBit = rd.nextInt(len);
				while(alterBit == 0)
				{
					alterBit = rd.nextInt(len);
				}
				temp[alterBit]=1;
				tempValue +=(1<<(len-1-alterBit));
			}
			
			/*   数组首元素表示符号,根据限制集对其赋值                   */
			if(positiveSet.contains(in) || unNegativeSet.contains(in))  // 不用改变temp[0]
			{
				; // donothing
			}
			else if(negativeSet.contains(in) || unPositiveSet.contains(in))  // 注意，这里100...0也表示数值0
			{
				temp[0]=1;
				tempValue = -1*tempValue;
			}
			else
			{
				if(Math.random()>=0.5)
				{
					temp[0]=1;
					tempValue = -1*tempValue;
				}
			}
			inputBits.add(temp);
			inputValue.add(new Long(tempValue));
		}
		
		/* 为auxilaryBits的每一个元素数组的每一位随即设为0或1，分配完毕后，计算对应的auxilaryValue中元素的值   */
		for(int i=0;i<auxilaryCount;i++)
		{
			int tempValue = 0;
			int[] temp = new int[len];
			Integer in = new Integer(i+1+inputCount);
			int tempExp = exp;
			
			
			/* 为非符号位赋值，注意当变量属于非零限制集合时的处理   */
			for(int j=1;j<len;j++)
			{
				if(Math.random()>=0.5)
				{
					temp[j]=1;
					tempValue += tempExp;
				}
				tempExp >>=1;
			}
			if(tempValue == 0 && ( unZeroSet.contains(in) ||
			        positiveSet.contains(in) ||
			        negativeSet.contains(in)) )  // 此时将整数部分某一非符号位置1
			{
				int alterBit = rd.nextInt(len);
				while(alterBit == 0)
				{
					alterBit = rd.nextInt(len);
				}
				temp[alterBit]=1;
				tempValue +=(1<<(len-1-alterBit));
			}
			
			/*   数组首元素表示符号,根据限制集进行赋值                   */
			if(positiveSet.contains(in) || unNegativeSet.contains(in))  // 不用改变temp[0]
			{
				; // donothing
			}
			else if(negativeSet.contains(in) || unPositiveSet.contains(in))  // 注意，这里100...0也表示数值0
			{
				temp[0]=1;
				tempValue = -1*tempValue;
			}
			else
			{
				if(Math.random()>=0.5)
				{
					temp[0]=1;
					tempValue = -1*tempValue;
				}
			}
			auxilaryBits.add(temp);
			auxilaryValue.add(new Long(tempValue));
		}
		
		/**
		 *   供测试
		 */
//		for(int i=0,siz=auxilaryValue.size();i<siz;i++)
//		{
//			Integer in = new Integer(i+1+inputCount);
////			if(!perturRangeSet.contains(new Integer(inputCount+i+1)))continue;
//			if((positiveSet.contains(in) && auxilaryValue.get(i).doubleValue()<= 0) ||
//					(unPositiveSet.contains(in) && auxilaryValue.get(i).doubleValue()> 0) ||
//							(negativeSet.contains(in) && auxilaryValue.get(i).doubleValue()>= 0) ||
//									(unNegativeSet.contains(in) && auxilaryValue.get(i).doubleValue()< 0) ||
//											(unZeroSet.contains(in) && auxilaryValue.get(i).doubleValue()== 0) )
//			{
//				System.out.println("\n！！！出错了！！！au"+(i+1)+"= "+auxilaryValue.get(i)+" ");
//				for(int j=0;j<len;j++)
//				System.out.print(" "+auxilaryBits.get(i)[j]+" ");
//				
////				double sum = 0.0;
////				for(int g=1;g<len;g++)
////				{
////					sum+=(Math.pow(2, leftSideLen-1-g)*mAuxilaryBits2.get(i)[g]);
////				}
////				sum *= (1-2*mAuxilaryBits2.get(i)[0]);
//////				System.out.print(sum);
////				if(sum!=mAuxilaryValue2.get(i))System.out.print("不匹配！！！！");
//				System.out.println();
//			}
//			else
//			{
//				System.out.print("au"+(i+1)+"= "+auxilaryValue.get(i)+" ");
//				for(int j=0;j<len;j++)
//				System.out.print(" "+auxilaryBits.get(i)[j]+" ");
//				
////				double sum = 0.0;
////				for(int g=1;g<len;g++)
////				{
////					sum+=(Math.pow(2, leftSideLen-1-g)*mAuxilaryBits2.get(i)[g]);
////				}
////				sum *= (1-2*mAuxilaryBits2.get(i)[0]);
//////				System.out.print(sum);
////				if(sum!=mAuxilaryValue2.get(i))System.out.print("不匹配！！！！");
//				System.out.println();
////				System.out.println();
//			}
//		}
	}
	
	
	/**
	 *  初始化配置(适用于浮点型输入变量，浮点型与整型混合输入变量）
	 */
	private static void initialConfiguration2(){  
		
		
		inputBits2 = new ArrayList<int[]>();
		auxilaryBits2 = new ArrayList<int[]>();
		inputValue2 = new ArrayList<Double>();
		auxilaryValue2 = new ArrayList<Double>();
		 
		/* 为inputBits2的每一个元素数组的每一位随即设为0或1，分配完毕后，计算对应的inputValue2中元素的值     */
		double maximalPower = 1<<(leftSideLen-2);
		Random  rd = new Random();
		double tempValue;
		int range;
		
		for(int i=0;i<inputCount;i++)
		{
			Integer in = new Integer(i+1);
			int[] temp = new int[len];
			if(intSet.contains(in)) // 变量必须是整数
			{
				range = leftSideLen-1;
			}
			else
			{
				range = len-1;
			}
			
			double tempExp = maximalPower;
			tempValue = 0.0;
			/* 为非符号位赋值*/
			for(int j=1;j<=range;j++)  
			{
				if(Math.random()>=0.5)
				{
					temp[j]=1;
					tempValue += tempExp;
				}
				tempExp /= 2;
			}
			 
			if(Double.compare(tempValue, 0.0)==0 && ( unZeroSet.contains(in) ||
					        positiveSet.contains(in) ||
					        negativeSet.contains(in)) )  // 此时将整数部分某一非符号位置1
			{
				int alterBit = rd.nextInt(range+1);
				while(alterBit == 0)
				{
					alterBit = rd.nextInt(range+1);
				}
				temp[alterBit]=1;
				tempValue += Math.pow(2,leftSideLen-1-alterBit);
			}
			
			/*   数组首元素表示符号,根据限制集对其赋值                   */
			if(positiveSet.contains(in) || unNegativeSet.contains(in))  // 不用改变temp[0]
			{
				; // donothing
			}
			else if(negativeSet.contains(in) || unPositiveSet.contains(in))  // 注意，这里100...0 . 00...0也表示数值0
			{
				temp[0]=1;
				tempValue = -tempValue;
			}
			else 
			{
				if(Math.random()>=0.5)
				{
					temp[0]=1;
					tempValue = -tempValue;
				}
			}
			inputBits2.add(temp);
			inputValue2.add(new Double(tempValue));
			temp =null;
			in =null;
		}
		
		/* 为auxilaryBits2的每一个元素数组的每一位随即设为0或1，分配完毕后，计算对应的auxilaryValue2中元素的值     */
		for(int i=0;i<auxilaryCount;i++)
		{
			
			int[] temp = new int[len];
			Integer in = new Integer(i+1+inputCount);
			
			if(intSet.contains(in)) // 变量必须是整数
			{
				range = leftSideLen-1;
			}
			else
			{
				range = len-1;
			}
			tempValue = 0.0;
			double tempExp = maximalPower;
			/* 为非符号位赋值*/
			for(int j=1;j<=range;j++)  // 整数部分
			{
				if(Math.random()>=0.5)
				{
					temp[j]=1;
					tempValue += tempExp;
				}
				tempExp /= 2;
			}
			
			if(Double.compare(tempValue, 0.0)==0 && ( unZeroSet.contains(in) ||
			        positiveSet.contains(in) ||
			        negativeSet.contains(in)) )  // 此时将整数部分某一非符号位置1
			{
				int alterBit = rd.nextInt(range+1);
				while(alterBit == 0)
				{
					alterBit = rd.nextInt(range+1);
				}
				temp[alterBit]=1;
				tempValue += Math.pow(2,leftSideLen-1-alterBit);
			}
			
			/*   数组首元素表示符号,根据限制集进行赋值                   */
			if(positiveSet.contains(in) || unNegativeSet.contains(in))  // 不用改变temp[0]
			{
				; // donothing
			}
			else if(negativeSet.contains(in) || unPositiveSet.contains(in))  // 注意，这里100...0 . 00...0也表示数值0
			{
				temp[0]=1;
				tempValue = -tempValue;
			}
			else
			{
				if(Math.random()>=0.5)
				{
					temp[0]=1;
					tempValue = -tempValue;
				}
			}
			auxilaryBits2.add(temp);
			auxilaryValue2.add(new Double(tempValue));
			temp =null;
			in =null;
		}
		
		/**
		 *   供测试
		 */
//		for(int i=0,siz=auxilaryValue2.size();i<siz;i++)
//		{
//			Integer in = new Integer(i+1+inputCount);
////			if(!perturRangeSet.contains(new Integer(inputCount+i+1)))continue;
//			if((positiveSet.contains(in) && auxilaryValue2.get(i).doubleValue()<= 0) ||
//					(unPositiveSet.contains(in) && auxilaryValue2.get(i).doubleValue()> 0) ||
//							(negativeSet.contains(in) && auxilaryValue2.get(i).doubleValue()>= 0) ||
//									(unNegativeSet.contains(in) && auxilaryValue2.get(i).doubleValue()< 0) ||
//											(unZeroSet.contains(in) && auxilaryValue2.get(i).doubleValue()== 0) )
//			{
//				System.out.println("\n！！！出错了！！！au"+(i+1)+"= "+auxilaryValue2.get(i)+" ");
//				for(int j=0;j<len;j++)
//				System.out.print(" "+auxilaryBits2.get(i)[j]+" ");
//				
////				double sum = 0.0;
////				for(int g=1;g<len;g++)
////				{
////					sum+=(Math.pow(2, leftSideLen-1-g)*mAuxilaryBits2.get(i)[g]);
////				}
////				sum *= (1-2*mAuxilaryBits2.get(i)[0]);
//////				System.out.print(sum);
////				if(sum!=mAuxilaryValue2.get(i))System.out.print("不匹配！！！！");
//				System.out.println();
//			}
//			else
//			{
//				System.out.print("au"+(i+1)+"= "+auxilaryValue2.get(i)+" ");
//				for(int j=0;j<len;j++)
//				System.out.print(" "+auxilaryBits2.get(i)[j]+" ");
//				
////				double sum = 0.0;
////				for(int g=1;g<len;g++)
////				{
////					sum+=(Math.pow(2, leftSideLen-1-g)*mAuxilaryBits2.get(i)[g]);
////				}
////				sum *= (1-2*mAuxilaryBits2.get(i)[0]);
//////				System.out.print(sum);
////				if(sum!=mAuxilaryValue2.get(i))System.out.print("不匹配！！！！");
//				System.out.println();
////				System.out.println();
//			}
//		}
	}
	
	/**
	 * 初始化临时配置（针对整型行参）
	 */
	private static void initialTempConfiguration()
	{
		/* 初始化临时配置（及其二进制表示数组）  */
		tempInputValue = new ArrayList<Long>(inputValue);
		tempInputBits = new ArrayList<int[]>();
		tempAuxilaryValue = new ArrayList<Long>(auxilaryValue);
		tempAuxilaryBits = new ArrayList<int[]>();
		for(int i=0,size=inputCount;i<size;i++)
		{
			int bits[] = inputBits.get(i);
			int tBits[] = bits.clone();
			tempInputBits.add(tBits);
			
		}
		for(int i=0,size=auxilaryCount;i<size;i++)
		{
			int bits[] = auxilaryBits.get(i);
			int tBits[] = bits.clone();
			tempAuxilaryBits.add(tBits);
		}
	}
	
	/**
	 * 初始化临时配置（针对浮点型或混合型行参）
	 */
	private static void initialTempConfiguration2()
	{
		/* 初始化临时配置（及其二进制表示数组）  */
		tempInputValue2 = new ArrayList<Double>(inputValue2);
		tempInputBits2 = new ArrayList<int[]>();
		tempAuxilaryValue2 = new ArrayList<Double>(auxilaryValue2);
		tempAuxilaryBits2 = new ArrayList<int[]>();
		for(int i=0,size=inputBits2.size();i<size;i++)
		{
			int bits[] = inputBits2.get(i);
			int tBits[] = bits.clone();
			tempInputBits2.add(tBits);
		}
		
		
		for(int i=0,size=auxilaryBits2.size();i<size;i++)
		{
			int bits[] = auxilaryBits2.get(i);
			int tBits[] = bits.clone();
			tempAuxilaryBits2.add(tBits);
		}
	}
	
	/**
	 *  初始化最小能源函数值的参数配置(针对整型行参）
	 */
	private static void initialMiniConfiguration()
	{
		mInputValue = new ArrayList<Long>(inputValue);
		mAuxilaryValue = new ArrayList<Long>(auxilaryValue);
	}
	
	
	/**
	 *  初始化最小能源函数值的参数配置(针对浮点型或混合型行参）
	 */
	private static void initialMiniConfiguration2()
	{
		mInputValue2 = new ArrayList<Double>(inputValue2);
		mAuxilaryValue2 = new ArrayList<Double>(auxilaryValue2);
	}
	
	
	
	/**
	 * 计算路径的能源函数的值(针对整型行参）
	 * @param path
	 * @return
	 */
	private static double calEnergyValue(CFGPath path){ 
		
		energyValue  = 0;     // 重新置为0

		for(int i=0;i<nodeEnergyValueSetInPath.size();i++)
		{
			energyValue += nodeEnergyValueSetInPath.get(i).doubleValue();
		}
		return energyValue;
	}
	
	
	/**
	 * 计算路径在临时配置下变化的能源函数的值(针对整型行参）
	 * @param path
	 */
	private static double calTempEnergyValue(CFGPath path){ 
		
		double tempValue = 0.0;
		int[]  nodeSet = nodeSetCorrectedWithVari[changeVari-1];   // 与改动变量有关的节点
		
		/* 更新 路径节点能源函数值变化量     */
		if(tempNodeEnergyValueSetInPath == null)
		{
			tempNodeEnergyValueSetInPath = new ArrayList<Double>();
		}
		else
		{
			tempNodeEnergyValueSetInPath.clear();
		}
		
		
		/* 重新设置finishCalNodeSet, 并计算新的节点能源函数值   */
		if(finishCalNodeSet == null)
		{
			finishCalNodeSet = new ArrayList<String>();  
		}
		else
		{
			finishCalNodeSet.clear();
		}
		
		List<SimpleCFGNode> list = path.getPath();
		for(int i=0;i<list.size();i++)   
		{
			SimpleCFGNode sno = list.get(i);
			
			/* 获取节点标号    */
			String nodeName = sno.getName();
			int number = Integer.parseInt(nodeName.trim().substring(4));
			
			 /* 节点与扰动变量没有关联     */
			if(!isInArray(number,nodeSet))
			{
				finishCalNodeSet.add(sno.getName());  // 添加完成计算的节点名称
				Double nodeValue = nodeEnergyValueSetInPath.get(i);
				tempNodeEnergyValueSetInPath.add(nodeValue);
				tempValue += nodeValue.doubleValue();
			}
			/* 节点与扰动变量有关联     */
			else  
			{
				double valueOfNode =  calTempNodeEnergyValue(sno);
				finishCalNodeSet.add(sno.getName());  // 添加完成计算的节点名称s
				tempNodeEnergyValueSetInPath.add(new Double(valueOfNode));
				tempValue += valueOfNode;
			}
		}
		return tempValue;
	}
	
	
	/**
	 * 计算路径的能源函数的值(针对浮点型或混合型行参）
	 * @param path
	 */
	private static double calEnergyValue2(CFGPath path){  
		
		energyValue2 = 0;     // 重新置为0

		for(int i=0,size=nodeEnergyValueSetInPath.size();i<size;i++)
		{
			energyValue2 += nodeEnergyValueSetInPath.get(i).doubleValue();
		}
		return energyValue2;
	}
	
	
	/**
	 * 计算路径在临时配置下变化的能源函数的值(针对浮点或混合型行参）
	 * @param path
	 */
	private static double calTempEnergyValue2(CFGPath path){ 
		
		double tempValue = 0.0;
		int[]  nodeSet = nodeSetCorrectedWithVari[changeVari-1];   // 与改动变量有关的节点
		
		/* 更新 路径节点能源函数值变化量     */
		if(tempNodeEnergyValueSetInPath != null)
		{
			tempNodeEnergyValueSetInPath.clear();
		}
		else
		{
			tempNodeEnergyValueSetInPath = new ArrayList<Double>();
		}
		
		
		/* 重新设置finishCalNodeSet, 并计算新的节点能源函数值   */
		if(finishCalNodeSet != null)
		{
			 finishCalNodeSet.clear();
		}
		else
		{
			finishCalNodeSet = new ArrayList<String>(); 
		}
		
		List<SimpleCFGNode> list = path.getPath();
		for(int i=0,size=list.size();i<size;i++)   
		{
			SimpleCFGNode sno = list.get(i);
			
			/* 获取节点标号    */
			String nodeName = sno.getName();
			int number = Integer.parseInt(nodeName.trim().substring(4));
			
			 /* 节点与扰动变量没有关联     */
			if(!isInArray(number,nodeSet))
			{
				finishCalNodeSet.add(nodeName);  // 添加完成计算的节点名称
				Double nodeValue = nodeEnergyValueSetInPath.get(i);
				tempNodeEnergyValueSetInPath.add(nodeValue);
				tempValue += nodeValue.doubleValue();
			}
			/* 节点与扰动变量有关联     */
			else  
			{
				double valueOfNode =  calTempNodeEnergyValue2(sno);
				finishCalNodeSet.add(nodeName);  // 添加完成计算的节点名称s
				tempNodeEnergyValueSetInPath.add(new Double(valueOfNode));
				tempValue += valueOfNode;
			}
		}
		return tempValue;
	}
	
	
	/**
	 * 计算分支节点的能源函数值(针对整型输入变量）
	 * @param node
	 * @return
	 */
	private static double calNodeEnergyValue(SimpleCFGNode node){
		
		String nodeName = node.getName();
		int number = Integer.parseInt(nodeName.trim().substring(4));
		int upBoundary = 1<<(leftSideLength-1);
		
		/**
		 *  for isLeapYear 
		 */
//			if(node.getName().equals("node2"))
//			{
//			    return 0;	
//			}
//			else if(node.getName().equals("node3"))
//			{
//				return calBinaryDiff( inputValue.get(0)%4, auxilaryValue.get(0));
//			}
//			else if(node.getName().equals("node4"))
//			{
//				return calBinaryDiff( inputValue.get(0)%4, 0);
//			}
//			else if(node.getName().equals("node5"))
//			{
//			    return calBinaryDiff( inputValue.get(0)%400, 0);	
//			}
//			else if(node.getName().equals("node6"))
//			{
//			    return calBinaryDiff( inputValue.get(0)%400, auxilaryValue.get(1));	
//			}
//			else if(node.getName().equals("node7"))
//			{
//				return calBinaryDiff( inputValue.get(0)%100, 0);
//			}
//			else if(node.getName().equals("node8"))
//			{
//				return calBinaryDiff( inputValue.get(0)%100, auxilaryValue.get(2));
//			}
//			else return 0;
		
		/**
		 * for triangle
		 */
//		if(node.getName().equals("node1") || node.getName().equals("node2"))
//		{
//			return 0;
//		}
//		else if(node.getName().equals("node3"))
//		{
//			return calBinaryDiff(inputValue.get(0).intValue(),auxilaryValue.get(0).intValue())+
//					calBinaryDiff(inputValue.get(1).intValue(),auxilaryValue.get(1).intValue())+
//					calBinaryDiff(inputValue.get(2).intValue(),auxilaryValue.get(2).intValue());
//		}
//		else if(node.getName().equals("node4"))
//		{
//			return calBinaryDiff(inputValue.get(0)+inputValue.get(1)-inputValue.get(2),auxilaryValue.get(3))+
//					calBinaryDiff(inputValue.get(0)+inputValue.get(2)-inputValue.get(1),auxilaryValue.get(4))+
//					calBinaryDiff(inputValue.get(2)+inputValue.get(1)-inputValue.get(0),auxilaryValue.get(5));
//		}
//		else if(node.getName().equals("node5"))
//		{
//			return calBinaryDiff(inputValue.get(0)-inputValue.get(1),0)*calBinaryDiff(inputValue.get(1)-inputValue.get(2),0);
//		}
//		else if(node.getName().equals("node6"))
//		{
//			return calBinaryDiff(inputValue.get(0)-inputValue.get(1),auxilaryValue.get(6))+calBinaryDiff(inputValue.get(1)-inputValue.get(2),auxilaryValue.get(7));
//		}
//		else if(node.getName().equals("node7"))
//		{
//			return calBinaryDiff(inputValue.get(0)*inputValue.get(0)+inputValue.get(1)*inputValue.get(1)-inputValue.get(2)*inputValue.get(2),0)*
//					calBinaryDiff(inputValue.get(1)*inputValue.get(1)+inputValue.get(2)*inputValue.get(2)-inputValue.get(0)*inputValue.get(0),0)*
//					calBinaryDiff(inputValue.get(0)*inputValue.get(0)+inputValue.get(2)*inputValue.get(2)-inputValue.get(1)*inputValue.get(1),0);
//		}
//		else if(node.getName().equals("node8"))
//		{
//			return calBinaryDiff(inputValue.get(0)*inputValue.get(0)+inputValue.get(1)*inputValue.get(1)-inputValue.get(2)*inputValue.get(2),auxilaryValue.get(8))*
//					calBinaryDiff(inputValue.get(1)*inputValue.get(1)+inputValue.get(2)*inputValue.get(2)-inputValue.get(0)*inputValue.get(0),auxilaryValue.get(9))*
//					calBinaryDiff(inputValue.get(0)*inputValue.get(0)+inputValue.get(2)*inputValue.get(2)-inputValue.get(1)*inputValue.get(1),auxilaryValue.get(10));
//		}
//		else if(node.getName().equals("node9"))
//		{
//			if(getPreNodeName(tpath,node).equals("node2"))
//			{
//				return calBinaryDiff(inputValue.get(0),auxilaryValue.get(14))*
//						calBinaryDiff(inputValue.get(1),auxilaryValue.get(15))*
//						calBinaryDiff(inputValue.get(2),auxilaryValue.get(16));
//			}
//			else if(getPreNodeName(tpath,node).equals("node3"))
//			{
//				return calBinaryDiff(inputValue.get(0)+inputValue.get(1)-inputValue.get(2),auxilaryValue.get(11))*
//						calBinaryDiff(inputValue.get(0)+inputValue.get(2)-inputValue.get(1),auxilaryValue.get(12))*
//						calBinaryDiff(inputValue.get(1)+inputValue.get(2)-inputValue.get(0),auxilaryValue.get(13));
//			}
//			else return 0;
//		}
//		else return 0;
		
		/**
		 *  for julday
		 */
//		int mm = inputValue.get(0).intValue();
//		int id = inputValue.get(1).intValue();
//		int iyyy = inputValue.get(2).intValue();
//		int jy  = iyyy;
//		
//		switch(number)
//		{
//		   case 3:
//		   {
//			   return (jy>=0?jy:upBoundary-jy);
//		   }
//		   case 4:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node2"))
//			   {
//				   return calBinaryDiff(jy,auxilaryValue.get(0));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//			   
//		   }
//		   case 5:
//		   {
//			   return calBinaryDiff(jy,auxilaryValue.get(2));
//		   }
//		   case 6:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node4"))
//			   {
//				   return calBinaryDiff(jy,auxilaryValue.get(1));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//		   }
//		   case 7:
//		   {
//			   return calBinaryDiff(mm-2,auxilaryValue.get(3));
//		   }
//		   case 8:
//		   {
//			   return calBinaryDiff(mm-2,auxilaryValue.get(4));
//		   }
//		   case 11:
//		   {
//			   int IGREG = 15+31*(10+12*1582);
//			   return calBinaryDiff(id+31*(mm+12*iyyy)-IGREG,auxilaryValue.get(5));
//		   }
//		   case 12:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node10"))
//			   {
//				   int IGREG = 15+31*(10+12*1582);
//				   return calBinaryDiff(id+31*(mm+12*iyyy)-IGREG,auxilaryValue.get(6));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//		   }
//		   default:
//		   {
//			   return 0;
//		   }
//		}
		
		/**
		 *  for caldat
		 */
//		int IGREG = 2299161;
//		int ja,jalpha,jb,jc,jd,je;
//		int julian = inputValue.get(0).intValue();
//		int mm = inputValue.get(1).intValue();
//		int id = inputValue.get(2).intValue();
//		int iyyy = inputValue.get(3).intValue();
//		switch(number)
//		{
//			case 3:
//			{
//				
//				return calBinaryDiff(inputValue.get(0)-IGREG,auxilaryValue.get(0));
//			}
//			case 4:
//			{
//				return calBinaryDiff(inputValue.get(0)-IGREG,auxilaryValue.get(1));
//			}
//			case 6:
//			{
//				return calBinaryDiff(inputValue.get(0),auxilaryValue.get(3));
//			}
//			case 5:
//			{
//				
//				return calBinaryDiff(inputValue.get(0),auxilaryValue.get(2));
//			}
//			case 9:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//				jd=(int)(365*jc+(0.25*jc));
//				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
//				mm=je-1;
//				
//				return calBinaryDiff(mm-12,auxilaryValue.get(4));
//			}
//			case 10:
//			{
//				if(!finishCalNodeSet.contains("node9"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//					jd=(int)(365*jc+(0.25*jc));
//					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
//					mm=je-1;
//					return calBinaryDiff(mm-12,auxilaryValue.get(5));
//				}
//				else return 0;
//			}
//			case 12:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//				jd=(int)(365*jc+(0.25*jc));
//				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
//				mm=je-1;
//				if(isNodeInPath("node9",tpath)==true)
//				{
//					mm -= 12;
//				}
////				iyyy=jc-4715;
//				return calBinaryDiff(mm-2,auxilaryValue.get(6));
//			}
//			case 13:
//			{
//				if(!finishCalNodeSet.contains("node12"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//					jd=(int)(365*jc+(0.25*jc));
//					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
//					mm=je-1;
//					if(isNodeInPath("node9",tpath)==true)
//					{
//						mm -= 12;
//					}
////					iyyy=jc-4715;
//					return calBinaryDiff(mm-2,auxilaryValue.get(7));
//				}
//				else return 0;
//			}
//			case 14:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
////				jd=(int)(365*jc+(0.25*jc));
////				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
////				mm=je-1;
////				if(isNodeInPath("node9",tpath)==true)
////				{
////					mm -= 12;
////				}
//				iyyy=jc-4715;
//				if(isNodeInPath("node12",tpath)==true)
//				{
//					--iyyy;
//				}
//				return calBinaryDiff(iyyy,auxilaryValue.get(8));
//			}
//			case 15:
//			{
//				if(!finishCalNodeSet.contains("node14"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
////					jd=(int)(365*jc+(0.25*jc));
////					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
////					mm=je-1;
////					if(isNodeInPath("node9",tpath)==true)
////					{
////						mm -= 12;
////					}
//					iyyy=jc-4715;
//					if(isNodeInPath("node12",tpath)==true)
//					{
//						--iyyy;
//					}
//					return calBinaryDiff(iyyy,auxilaryValue.get(9));
//				}
//				else return 0;
//			}
//			case 16:
//			{
//				return calBinaryDiff(inputValue.get(0),auxilaryValue.get(10));
//			}
//			case 17:
//			{
//				if(!finishCalNodeSet.contains("node16"))
//				{
//					return calBinaryDiff(inputValue.get(0),auxilaryValue.get(11));
//				}
//				else return 0;
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 * for icrc
		 */
		short crc = inputValue.get(0).shortValue();
		long len = inputValue.get(1).longValue();
		short jinit = inputValue.get(2).shortValue();
		int jrev = inputValue.get(3).intValue();
		
		switch(number)
		{
			case 7:
			{
				return calBinaryDiff(jinit,auxilaryValue.get(0));
			}
			case 8:
			{
				return calBinaryDiff(jinit,auxilaryValue.get(1));
			}
			case 9:
			{
				return calBinaryDiff(jrev,auxilaryValue.get(2));
			}
			case 10:
			{
				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node8"))
				{
					return calBinaryDiff(jrev,auxilaryValue.get(3));
				}
				else
				{
					return 0;
				}
			}
			case 11:
			{
				return calBinaryDiff(1-len,auxilaryValue.get(5));
			}
			case 15:
			{
				if(!finishCalNodeSet.contains("node11"))
				{
					return calBinaryDiff(1-len,auxilaryValue.get(4));
				}
				else
				{
					return 0;
				}
				
			}
			case 12:
			{
				return calBinaryDiff(jrev,auxilaryValue.get(6));
			}
			case 13:
			{
				return calBinaryDiff(jrev,auxilaryValue.get(7));
			}
			case 16:
			{
				return calBinaryDiff(jrev,auxilaryValue.get(8));
			}
			case 17:
			{
				return calBinaryDiff(jrev,auxilaryValue.get(9));
			}
			default:
			{
				return 0;
			}
		}
}
	
	
	/**
	 * 计算分支节点在临时配置下的能源函数值(针对整型输入变量）
	 * @param node
	 * @return
	 */
	private static double calTempNodeEnergyValue(SimpleCFGNode node){
		String nodeName = node.getName();
		int number = Integer.parseInt(nodeName.trim().substring(4));
		int upBoundary = 1<<(leftSideLength-1);
		
		/**
		 *  for isLeapYear 
		 */
//		if(node.getName().equals("node2"))
//		{
//		    return 0;	
//		}
//		else if(node.getName().equals("node3"))
//		{
//			return calBinaryDiff( tempInputValue.get(0)%4, tempAuxilaryValue.get(0));
//		}
//		else if(node.getName().equals("node4"))
//		{
//			return calBinaryDiff( tempInputValue.get(0)%4, 0);
//		}
//		else if(node.getName().equals("node5"))
//		{
//		    return calBinaryDiff( tempInputValue.get(0)%400, 0);	
//		}
//		else if(node.getName().equals("node6"))
//		{
//		    return calBinaryDiff( tempInputValue.get(0)%400, tempAuxilaryValue.get(1));	
//		}
//		else if(node.getName().equals("node7"))
//		{
//			return calBinaryDiff( tempInputValue.get(0)%100, 0);
//		}
//		else if(node.getName().equals("node8"))
//		{
//			return calBinaryDiff( tempInputValue.get(0)%100, tempAuxilaryValue.get(2));
//		}
//		else return 0;
		
		/**
		 * for triangle
		 */
//		if(node.getName().equals("node1") || node.getName().equals("node2"))
//		{
//			return 0;
//		}
//		else if(node.getName().equals("node3"))
//		{
//			return calBinaryDiff(tempInputValue.get(0).intValue(),tempAuxilaryValue.get(0).intValue())+
//					calBinaryDiff(tempInputValue.get(1).intValue(),tempAuxilaryValue.get(1).intValue())+
//					calBinaryDiff(tempInputValue.get(2).intValue(),tempAuxilaryValue.get(2).intValue());
//		}
//		else if(node.getName().equals("node4"))
//		{
//			return calBinaryDiff(tempInputValue.get(0)+tempInputValue.get(1)-tempInputValue.get(2),tempAuxilaryValue.get(3))+
//					calBinaryDiff(tempInputValue.get(0)+tempInputValue.get(2)-tempInputValue.get(1),tempAuxilaryValue.get(4))+
//					calBinaryDiff(tempInputValue.get(2)+tempInputValue.get(1)-tempInputValue.get(0),tempAuxilaryValue.get(5));
//		}
//		else if(node.getName().equals("node5"))
//		{
//			return calBinaryDiff(tempInputValue.get(0)-tempInputValue.get(1),0)*calBinaryDiff(tempInputValue.get(1)-tempInputValue.get(2),0);
//		}
//		else if(node.getName().equals("node6"))
//		{
//			return calBinaryDiff(tempInputValue.get(0)-tempInputValue.get(1),tempAuxilaryValue.get(6))+calBinaryDiff(tempInputValue.get(1)-tempInputValue.get(2),tempAuxilaryValue.get(7));
//		}
//		else if(node.getName().equals("node7"))
//		{
//			return calBinaryDiff(tempInputValue.get(0)*tempInputValue.get(0)+tempInputValue.get(1)*tempInputValue.get(1)-tempInputValue.get(2)*tempInputValue.get(2),0)*
//					calBinaryDiff(tempInputValue.get(1)*tempInputValue.get(1)+tempInputValue.get(2)*tempInputValue.get(2)-tempInputValue.get(0)*tempInputValue.get(0),0)*
//					calBinaryDiff(tempInputValue.get(0)*tempInputValue.get(0)+tempInputValue.get(2)*tempInputValue.get(2)-tempInputValue.get(1)*tempInputValue.get(1),0);
//		}
//		else if(node.getName().equals("node8"))
//		{
//			return calBinaryDiff(tempInputValue.get(0)*tempInputValue.get(0)+tempInputValue.get(1)*tempInputValue.get(1)-tempInputValue.get(2)*tempInputValue.get(2),tempAuxilaryValue.get(8))*
//					calBinaryDiff(tempInputValue.get(1)*tempInputValue.get(1)+tempInputValue.get(2)*tempInputValue.get(2)-tempInputValue.get(0)*tempInputValue.get(0),tempAuxilaryValue.get(9))*
//					calBinaryDiff(tempInputValue.get(0)*tempInputValue.get(0)+tempInputValue.get(2)*tempInputValue.get(2)-tempInputValue.get(1)*tempInputValue.get(1),tempAuxilaryValue.get(10));
//		}
//		else if(node.getName().equals("node9"))
//		{
//			if(getPreNodeName(tpath,node).equals("node2"))
//			{
//				return calBinaryDiff(tempInputValue.get(0),tempAuxilaryValue.get(14))*
//						calBinaryDiff(tempInputValue.get(1),tempAuxilaryValue.get(15))*
//						calBinaryDiff(tempInputValue.get(2),tempAuxilaryValue.get(16));
//			}
//			else if(getPreNodeName(tpath,node).equals("node3"))
//			{
//				return calBinaryDiff(tempInputValue.get(0)+tempInputValue.get(1)-tempInputValue.get(2),tempAuxilaryValue.get(11))*
//						calBinaryDiff(tempInputValue.get(0)+tempInputValue.get(2)-tempInputValue.get(1),tempAuxilaryValue.get(12))*
//						calBinaryDiff(tempInputValue.get(1)+tempInputValue.get(2)-tempInputValue.get(0),tempAuxilaryValue.get(13));
//			}
//			else return 0;
//		}
//		else return 0;
		
		/**
		 *  for julday
		 */
//		int mm = tempInputValue.get(0).intValue();
//		int id = tempInputValue.get(1).intValue();
//		int iyyy = tempInputValue.get(2).intValue();
//		int jy  = iyyy;
//		
//		switch(number)
//		{
//		   case 3:
//		   {
//			   return (jy>=0?jy:upBoundary-jy);
//		   }
//		   case 4:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node2"))
//			   {
//				   return calBinaryDiff(jy,tempAuxilaryValue.get(0));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//			   
//		   }
//		   case 5:
//		   {
//			   return calBinaryDiff(jy,tempAuxilaryValue.get(2));
//		   }
//		   case 6:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node4"))
//			   {
//				   return calBinaryDiff(jy,tempAuxilaryValue.get(1));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//		   }
//		   case 7:
//		   {
//			   return calBinaryDiff(mm-2,tempAuxilaryValue.get(3));
//		   }
//		   case 8:
//		   {
//			   return calBinaryDiff(mm-2,tempAuxilaryValue.get(4));
//		   }
//		   case 11:
//		   {
//			   int IGREG = 15+31*(10+12*1582);
//			   return calBinaryDiff(id+31*(mm+12*iyyy)-IGREG,tempAuxilaryValue.get(5));
//		   }
//		   case 12:
//		   {
//			   if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node10"))
//			   {
//				   int IGREG = 15+31*(10+12*1582);
//				   return calBinaryDiff(id+31*(mm+12*iyyy)-IGREG,tempAuxilaryValue.get(6));
//			   }
//			   else
//			   {
//				   return 0;
//			   }
//		   }
//		   default:
//		   {
//			   return 0;
//		   }
//		}
		
		/**
		 *  for caldat
		 */
//		int IGREG = 2299161;
//		int ja,jalpha,jb,jc,jd,je;
//		int julian = tempInputValue.get(0).intValue();
//		int mm = tempInputValue.get(1).intValue();
//		int id = tempInputValue.get(2).intValue();
//		int iyyy = tempInputValue.get(3).intValue();
//		switch(number)
//		{
//			case 3:
//			{
//				
//				return calBinaryDiff(tempInputValue.get(0)-IGREG,tempAuxilaryValue.get(0));
//			}
//			case 4:
//			{
//				return calBinaryDiff(tempInputValue.get(0)-IGREG,tempAuxilaryValue.get(1));
//			}
//			case 6:
//			{
//				return calBinaryDiff(tempInputValue.get(0),tempAuxilaryValue.get(3));
//			}
//			case 5:
//			{
//				
//				return calBinaryDiff(tempInputValue.get(0),tempAuxilaryValue.get(2));
//			}
//			case 9:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//				jd=(int)(365*jc+(0.25*jc));
//				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
//				mm=je-1;
//				
//				return calBinaryDiff(mm-12,tempAuxilaryValue.get(4));
//			}
//			case 10:
//			{
//				if(!finishCalNodeSet.contains("node9"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//					jd=(int)(365*jc+(0.25*jc));
//					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
//					mm=je-1;
//					return calBinaryDiff(mm-12,tempAuxilaryValue.get(5));
//				}
//				else return 0;
//			}
//			case 12:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//				jd=(int)(365*jc+(0.25*jc));
//				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
//				mm=je-1;
//				if(isNodeInPath("node9",tpath)==true)
//				{
//					mm -= 12;
//				}
////				iyyy=jc-4715;
//				return calBinaryDiff(mm-2,tempAuxilaryValue.get(6));
//			}
//			case 13:
//			{
//				if(!finishCalNodeSet.contains("node12"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
//					jd=(int)(365*jc+(0.25*jc));
//					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
//					mm=je-1;
//					if(isNodeInPath("node9",tpath)==true)
//					{
//						mm -= 12;
//					}
////					iyyy=jc-4715;
//					return calBinaryDiff(mm-2,tempAuxilaryValue.get(7));
//				}
//				else return 0;
//			}
//			case 14:
//			{
//				if(isNodeInPath("node3",tpath)==true)
//				{
//					jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//					ja=julian+1+jalpha-(int)(0.25*jalpha);
//				}
//				else if(isNodeInPath("node5",tpath)==true)
//				{
//					ja=julian+36525*(1-julian/36525);
//				}
//				else  //(isNodeInPath("node6",tpath)==true)
//				{
//					ja = julian;
//				}
//				jb=ja+1524;
//				jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
////				jd=(int)(365*jc+(0.25*jc));
////				je=(int)((jb-jd)/30.6001);
////				id=jb-jd-(int)(30.6001*je);
////				mm=je-1;
////				if(isNodeInPath("node9",tpath)==true)
////				{
////					mm -= 12;
////				}
//				iyyy=jc-4715;
//				if(isNodeInPath("node12",tpath)==true)
//				{
//					--iyyy;
//				}
//				return calBinaryDiff(iyyy,tempAuxilaryValue.get(8));
//			}
//			case 15:
//			{
//				if(!finishCalNodeSet.contains("node14"))
//				{
//					if(isNodeInPath("node3",tpath)==true)
//					{
//						jalpha=(int)(((julian-1867216)-0.25)/36524.25);
//						ja=julian+1+jalpha-(int)(0.25*jalpha);
//					}
//					else if(isNodeInPath("node5",tpath)==true)
//					{
//						ja=julian+36525*(1-julian/36525);
//					}
//					else  //(isNodeInPath("node6",tpath)==true)
//					{
//						ja = julian;
//					}
//					jb=ja+1524;
//					jc=(int)(6680.0+((jb-2439870)-122.1)/365.25);
////					jd=(int)(365*jc+(0.25*jc));
////					je=(int)((jb-jd)/30.6001);
////					id=jb-jd-(int)(30.6001*je);
////					mm=je-1;
////					if(isNodeInPath("node9",tpath)==true)
////					{
////						mm -= 12;
////					}
//					iyyy=jc-4715;
//					if(isNodeInPath("node12",tpath)==true)
//					{
//						--iyyy;
//					}
//					return calBinaryDiff(iyyy,tempAuxilaryValue.get(9));
//				}
//				else return 0;
//			}
//			case 16:
//			{
//				return calBinaryDiff(tempInputValue.get(0),tempAuxilaryValue.get(10));
//			}
//			case 17:
//			{
//				if(!finishCalNodeSet.contains("node16"))
//				{
//					return calBinaryDiff(tempInputValue.get(0),tempAuxilaryValue.get(11));
//				}
//				else return 0;
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 * for icrc
		 */
		short crc = tempInputValue.get(0).shortValue();
		long len = tempInputValue.get(1).longValue();
		short jinit = tempInputValue.get(2).shortValue();
		int jrev = tempInputValue.get(3).intValue();
		
		switch(number)
		{
			case 7:
			{
				return calBinaryDiff(jinit,tempAuxilaryValue.get(0));
			}
			case 8:
			{
				return calBinaryDiff(jinit,tempAuxilaryValue.get(1));
			}
			case 9:
			{
				return calBinaryDiff(jrev,tempAuxilaryValue.get(2));
			}
			case 10:
			{
				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node8"))
				{
					return calBinaryDiff(jrev,tempAuxilaryValue.get(3));
				}
				else
				{
					return 0;
				}
			}
			case 11:
			{
				return calBinaryDiff(1-len,tempAuxilaryValue.get(5));
			}
			case 15:
			{
				if(!finishCalNodeSet.contains("node11"))
				{
					return calBinaryDiff(1-len,tempAuxilaryValue.get(4));
				}
				else
				{
					return 0;
				}
			}
			case 12:
			{
				return calBinaryDiff(jrev,tempAuxilaryValue.get(6));
			}
			case 13:
			{
				return calBinaryDiff(jrev,tempAuxilaryValue.get(7));
			}
			case 16:
			{
				return calBinaryDiff(jrev,tempAuxilaryValue.get(8));
			}
			case 17:
			{
				return calBinaryDiff(jrev,tempAuxilaryValue.get(9));
			}
			default:
			{
				return 0;
			}
		}
	}
	
	
	/**
	 * 计算分支节点的能源函数值(针对浮点型或混合型输入变量）
	 * @param node
	 * @return
	 */
	private static double calNodeEnergyValue2(SimpleCFGNode node){
		
		String nodeName = node.getName();
		int number = Integer.parseInt(nodeName.trim().substring(4));
//		double upBound = 1<<(leftSideLength-1);
		
		/**
		 *  for expint
		 */
//		int n = inputValue2.get(0).intValue();
//		double x = inputValue2.get(1);
//		double EULER=0.577215664901533;
//		double EPS=(2.22044604925031308085e-16);
//		double max=1.79769313486231570815e+308;
//		double BIG = max*EPS;
//		switch(number)
//		{
//			case 3:
//			{
//				double r1 = (x>=0?x:(-x+upBound));
//				double r2 = (n>=0?n:(-n+upBound));
//				double r3 = (n-1>=0?n-1:1-n+upBound);
//				return calBinaryDiff(n,auxilaryValue2.get(0).intValue())*
//						calBinaryDiff2(x,auxilaryValue2.get(1))*
//					   (r1+r2*r3);
//			}
//			case 4:
//			{
//				return calBinaryDiff(n,auxilaryValue2.get(2).intValue())+
//						calBinaryDiff2(x,auxilaryValue2.get(3))+
//						calBinaryDiff2(x,auxilaryValue2.get(4))*
//						(calBinaryDiff(n,auxilaryValue2.get(5).intValue())+
//						  calBinaryDiff(n-1,auxilaryValue2.get(6).intValue()))	;
//			}
//			case 5:
//			{
//				double r2 = (n>=0?n:(-n+upBound));
//				return r2;
//			}
//			case 6:
//			{
//				return calBinaryDiff(n,auxilaryValue2.get(7).intValue());
//			}
//			case 7:
//			{
//				double r1 = (x>=0?x:(-x+upBound));
//				return r1;
//			}
//			case 8:
//			{
//				return calBinaryDiff2(x,auxilaryValue2.get(8));
//			}
//			case 9:
//			{
//				return calBinaryDiff2(x-1,auxilaryValue2.get(9));
//			}
//			case 10:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node12"))
//				{
//						double b = n+x;
//						double c = BIG;
//						double d = 1.0/b;
//			           double a = -1*n;
//			           b += 2.0;
//			           d = 1.0/(a*d+b);
//			           c = b+a/c;
//			           double del = c*d;
//						 return calBinaryDiff2(Math.abs(del-1.0)-EPS,auxilaryValue2.get(16));
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 13:
//			{
//				double b = n+x;
//				double c = BIG;
//				double d = 1.0/b;
//	           double a = -1*n;
//	           b += 2.0;
//	           d = 1.0/(a*d+b);
//	           c = b+a/c;
//	           double del = c*d;
//				 return calBinaryDiff2(Math.abs(del-1.0)-EPS,auxilaryValue2.get(10));
//			}
//			case 15:
//			{
//				return calBinaryDiff2(x-1,auxilaryValue2.get(11));
//			}
//			case 16:
//			{
//				double ans =(n-1!=0 ? 1.0/(n-1) : -Math.log(x)-EULER);
//			    double del;
//			    double firstNumber;
//			    if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node25") &&
//			        isNodeInPath("node19",tpath))
//			     {
//						del = x/(2-n);
//						ans += del;
//						firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//						return calBinaryDiff2(firstNumber,auxilaryValue2.get(18));
//				}
//				else if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node25") &&
//			        isNodeInPath("node20",tpath))
//				{
//					double psi = -EULER;
//					for(int ii=1;ii<=n-1;ii++)
//					{
//						psi += 1.0/ii;
//					}
//					del = -x*(psi-Math.log(x));
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,auxilaryValue2.get(19));
//				}
//			    else
//			    {
//			    	return 0;
//			    }
//			}
//			case 19:
//			{
//				return calBinaryDiff(n-2,auxilaryValue2.get(12).intValue());
//			}
//			case 20:
//			{
//				double r = (n-2>=0?n-2:2-n+upBound);
//				return r;
//			}
//			case 22:
//			{
//				return calBinaryDiff(n-2,auxilaryValue2.get(13).intValue());
//			}
//			case 23:
//			{
//				return calBinaryDiff(n-2,auxilaryValue2.get(17).intValue());
//			}
//			case 26:
//			{
//				double ans =(n-1!=0 ? 1.0/(n-1) : -Math.log(x)-EULER);
//				double del;
//				double firstNumber;
//				if(isNodeInPath("node19",tpath))
//				{
//					del = x/(2-n);
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,auxilaryValue2.get(14));
//				}
//				else //isNodeInPath("node20",tpath)
//				{
//					double psi = -EULER;
//					for(int ii=1;ii<=n-1;ii++)
//					{
//						psi += 1.0/ii;
//					}
//					del = -x*(psi-Math.log(x));
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,auxilaryValue2.get(15));
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		
		/**
		 *  for bessj
		 */
//		double dmin = 2.22507385850720138309e-308;
//		double boundary = 1<<(leftSideLength-1);
//		switch(number){
//		
//			
//			case 3:
//			{
//				return calBinaryDiff(inputValue2.get(0).longValue()-2,auxilaryValue2.get(0).longValue());  // 整
//			}
//			case 4:
//			{
//				if(!finishCalNodeSet.contains("node3"))
//				{
//					return calBinaryDiff(inputValue2.get(0).longValue()-2,auxilaryValue2.get(1).longValue()); // 整
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 6:
//			{
//				return calBinaryDiff2(inputValue2.get(1)*inputValue2.get(1)-8*dmin,auxilaryValue2.get(2));
//			}
//			case 7:
//			{
//				return calBinaryDiff2(inputValue2.get(1)*inputValue2.get(1)-8*dmin,auxilaryValue2.get(3));
//			}
//			case 8:
//			{
//				return calBinaryDiff2(Math.abs(inputValue2.get(1))-inputValue2.get(0),auxilaryValue2.get(4));
//			}
//			case 10:
//			{
//				return calBinaryDiff(1-inputValue2.get(0).longValue(),auxilaryValue2.get(9).longValue());  // 整
//			}
//			case 11:
//			{
//				if(!isNodeInPath("node10",tpath))
//				{
//					return calBinaryDiff(1-inputValue2.get(0).longValue(),auxilaryValue2.get(10).longValue());  // 整
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 12:
//			{
//				return calBinaryDiff2(Math.abs(inputValue2.get(1))-inputValue2.get(0),auxilaryValue2.get(5));
//			}
//			case 13:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node20"))
//				{
//						int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));
//						return calBinaryDiff(m-inputValue2.get(0).longValue(),auxilaryValue2.get(7).longValue());  // 整
//				}
//				else 
//				{
//					return 0;
//				}
//			}
//			case 14:
//			{
//					int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));  // 整
//					return calBinaryDiff(m,auxilaryValue2.get(14).longValue());
//			}
//			case 16:
//			{
//					int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));  // 整
//					int IEXP = 512;
//					int z = (int)(Math.getExponent(m*2.0/Math.abs(inputValue2.get(1))))-IEXP;
//					return calBinaryDiff(z,auxilaryValue2.get(6).longValue());
//			}
//			case 17:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node15"))
//				{
//						int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));
//						int IEXP = 512;
//						int z = (int)(Math.getExponent(m*2.0/Math.abs(inputValue2.get(1))))-IEXP;
//						return calBinaryDiff(z,auxilaryValue2.get(8).longValue());   // 整
//				}
//				else 
//				{
//					return 0;
//				}
//				
//			}
//			case 21: // 整
//			{
//					int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));
////				    return calBinaryDiff2(m-inputValue2.get(0),0);
//				    if(m-inputValue2.get(0).intValue()>=0)
//				    {
//				    	return m-inputValue2.get(0).intValue();
//				    }
//				    else
//				    {
//				    	return -(m-inputValue2.get(0).intValue())+boundary;
//				    }
//			}
//			case 22: // 整
//			{
//				if(!finishCalNodeSet.contains("node14"))
//				{
//					int m = inputValue2.get(0).intValue()+(int)(Math.sqrt(160*inputValue2.get(0)));
//				    return calBinaryDiff(m,auxilaryValue2.get(13).longValue());
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 *  for plgndr
		 */
//		switch(number)
//		{
//			case 3:
//			{
//				return calBinaryDiff2(inputValue2.get(1),auxilaryValue2.get(0))*
//						calBinaryDiff2(inputValue2.get(1)-inputValue2.get(0),auxilaryValue2.get(1))*
//						calBinaryDiff2(Math.abs(inputValue2.get(2))-1.0,auxilaryValue2.get(2));
//			}
//			case 4:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node2"))
//				{
//					return calBinaryDiff2(inputValue2.get(1),auxilaryValue2.get(3))+
//							calBinaryDiff2(inputValue2.get(1)-inputValue2.get(0),auxilaryValue2.get(4))+
//							calBinaryDiff2(Math.abs(inputValue2.get(2))-1.0,auxilaryValue2.get(5));
//				}
//				else return 0;
//			}
//			case 6:
//			{
//				return calBinaryDiff2(inputValue2.get(1),auxilaryValue2.get(6));
//			}
//			case 8:
//			{
//				return calBinaryDiff2(inputValue2.get(1)-1,auxilaryValue2.get(8));
//			}
//			case 9:
//			{
//				if(getPreNodeName(tpath,node).equals("node5"))
//				{
//					return calBinaryDiff2(inputValue2.get(1),auxilaryValue2.get(7));
//				}
//				else if(getPreNodeName(tpath,node).equals("node7")&& !isNodeInPath("node8",tpath))
//				{
//					return calBinaryDiff2(inputValue2.get(1)-1,auxilaryValue2.get(9));
//				}
//				else return 0;
//			}
//			case 10:
//			{
//				return calBinaryDiff2(inputValue2.get(0)-inputValue2.get(1),0);
//			}
//			case 11:
//			{
//				return calBinaryDiff2(inputValue2.get(0)-inputValue2.get(1),auxilaryValue2.get(10));
//			}
//			case 13:
//			{
//				return calBinaryDiff2(inputValue2.get(0)-inputValue2.get(1)-1,0);
//			}
//			case 14:
//			{
//				return calBinaryDiff2(inputValue2.get(0)-inputValue2.get(1)-1,auxilaryValue2.get(11));
//			}
//			case 15:
//			{
//				return calBinaryDiff2(inputValue2.get(1)-inputValue2.get(0)+2,auxilaryValue2.get(12));
//			}
//			case 16:
//			{
//				if(!isNodeInPath("node15",tpath))
//				{
//					return calBinaryDiff2(inputValue2.get(1)-inputValue2.get(0)+2,auxilaryValue2.get(13));
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 *  for ei
		 */
		double EPS = 2.22044604925031308085e-16;
		double FPMIN = 2.22507385850720138309e-308/EPS;
		double x = inputValue2.get(0).doubleValue();
		switch(number)
		{
			case 3:
			{
				return calBinaryDiff2(x,auxilaryValue2.get(0));
			}
			case 4:
			{
				return calBinaryDiff2(x,auxilaryValue2.get(1));
			}
			case 5:
			{
				return calBinaryDiff2(x-FPMIN,auxilaryValue2.get(2));
			}
			case 6:
			{
				return calBinaryDiff2(x-FPMIN,auxilaryValue2.get(11));
			}
			case 7:
			{
				return calBinaryDiff2(x+Math.log(EPS),auxilaryValue2.get(3));
			}
			case 8:
			{
				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node10"))
				{
					return calBinaryDiff2(x,auxilaryValue2.get(6));
				}
				else return 0;
			}
			case 11:
			{
					return calBinaryDiff2(x,auxilaryValue2.get(5));
			}
			case 15:
			{
				return calBinaryDiff2(x+Math.log(EPS),auxilaryValue2.get(4));
			}
			case 19:
			{
					return calBinaryDiff2(1/x-EPS,auxilaryValue2.get(7));
			}
			case 20:
			{
					return calBinaryDiff2(1/x-EPS,auxilaryValue2.get(8));
			}
			case 21:
			{
					return calBinaryDiff2(1/x-1,auxilaryValue2.get(9));
			}
			case 22:
			{
					return calBinaryDiff2(1/x-1,auxilaryValue2.get(10));
			}
			default:
			{
				return 0;
			}
		}
	}
	
	
	/**
	 * 计算分支节点在临时配置下的能源函数值(针对浮点型或混合型输入变量）
	 * @param node
	 * @return
	 */
	private static double calTempNodeEnergyValue2(SimpleCFGNode node){
		
		String nodeName = node.getName();
		int number = Integer.parseInt(nodeName.trim().substring(4));
//		double upBound = 1<<(leftSideLength-1);
		
		/**
		 *  for expint
		 */
//		int n = tempInputValue2.get(0).intValue();
//		double x = tempInputValue2.get(1);
//		double EULER=0.577215664901533;
//		double EPS=(2.22044604925031308085e-16);
//		double max=1.79769313486231570815e+308;
//		double BIG = max*EPS;
//		switch(number)
//		{
//			case 3:
//			{
//				double r1 = (x>=0?x:(-x+upBound));
//				double r2 = (n>=0?n:(-n+upBound));
//				double r3 = (n-1>=0?n-1:1-n+upBound);
//				return calBinaryDiff(n,tempAuxilaryValue2.get(0).intValue())*
//						calBinaryDiff2(x,tempAuxilaryValue2.get(1))*
//					   (r1+r2*r3);
//			}
//			case 4:
//			{
//				return calBinaryDiff(n,tempAuxilaryValue2.get(2).intValue())+
//						calBinaryDiff2(x,tempAuxilaryValue2.get(3))+
//						calBinaryDiff2(x,tempAuxilaryValue2.get(4))*
//						(calBinaryDiff(n,tempAuxilaryValue2.get(5).intValue())+
//						  calBinaryDiff(n-1,tempAuxilaryValue2.get(6).intValue()))	;
//			}
//			case 5:
//			{
//				double r2 = (n>=0?n:(-n+upBound));
//				return r2;
//			}
//			case 6:
//			{
//				return calBinaryDiff(n,tempAuxilaryValue2.get(7).intValue());
//			}
//			case 7:
//			{
//				double r1 = (x>=0?x:(-x+upBound));
//				return r1;
//			}
//			case 8:
//			{
//				return calBinaryDiff2(x,tempAuxilaryValue2.get(8));
//			}
//			case 9:
//			{
//				return calBinaryDiff2(x-1,tempAuxilaryValue2.get(9));
//			}
//			case 10:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node12"))
//				{
//						double b = n+x;
//						double c = BIG;
//						double d = 1.0/b;
//			           double a = -1*n;
//			           b += 2.0;
//			           d = 1.0/(a*d+b);
//			           c = b+a/c;
//			           double del = c*d;
//						 return calBinaryDiff2(Math.abs(del-1.0)-EPS,tempAuxilaryValue2.get(16));
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 13:
//			{
//				double b = n+x;
//				double c = BIG;
//				double d = 1.0/b;
//	           double a = -1*n;
//	           b += 2.0;
//	           d = 1.0/(a*d+b);
//	           c = b+a/c;
//	           double del = c*d;
//				 return calBinaryDiff2(Math.abs(del-1.0)-EPS,tempAuxilaryValue2.get(10));
//			}
//			case 15:
//			{
//				return calBinaryDiff2(x-1,tempAuxilaryValue2.get(11));
//			}
//			case 16:
//			{
//				double ans =(n-1!=0 ? 1.0/(n-1) : -Math.log(x)-EULER);
//			    double del;
//			    double firstNumber;
//			    if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node25") &&
//			        isNodeInPath("node19",tpath))
//			     {
//						del = x/(2-n);
//						ans += del;
//						firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//						return calBinaryDiff2(firstNumber,tempAuxilaryValue2.get(18));
//				}
//				else if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node25") &&
//			        isNodeInPath("node20",tpath))
//				{
//					double psi = -EULER;
//					for(int ii=1;ii<=n-1;ii++)
//					{
//						psi += 1.0/ii;
//						del = -x/(2-n);
//						ans += del;
//						firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					}
//					del = -x*(psi-Math.log(x));
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,tempAuxilaryValue2.get(19));
//				}
//			    else
//			    {
//			    	return 0;
//			    }
//			}
//			case 19:
//			{
//				return calBinaryDiff(n-2,tempAuxilaryValue2.get(12).intValue());
//			}
//			case 20:
//			{
//				double r = (n-2>=0?n-2:2-n+upBound);
//				return r;
//			}
//			case 22:
//			{
//				return calBinaryDiff(n-2,tempAuxilaryValue2.get(13).intValue());
//			}
//			case 23:
//			{
//				return calBinaryDiff(n-2,tempAuxilaryValue2.get(17).intValue());
//			}
//			case 26:
//			{
//				double ans =(n-1!=0 ? 1.0/(n-1) : -Math.log(x)-EULER);
//				double del;
//				double firstNumber;
//				if(isNodeInPath("node19",tpath))
//				{
//					del = x/(2-n);
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,tempAuxilaryValue2.get(14));
//				}
//				else //isNodeInPath("node20",tpath)
//				{
//					double psi = -EULER;
//					for(int ii=1;ii<=n-1;ii++)
//					{
//						psi += 1.0/ii;
//					}
//					del = -x*(psi-Math.log(x));
//					ans += del;
//					firstNumber = Math.abs(del)-Math.abs(ans)*EPS;
//					return calBinaryDiff2(firstNumber,tempAuxilaryValue2.get(15));
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 *  for bessj
		 */
// 		double dmin = 2.22507385850720138309e-308;
//		double boundary = 1<<(leftSideLength-1);
//		switch(number){
//		
//			
//			case 3:
//			{
//				return calBinaryDiff(tempInputValue2.get(0).longValue()-2,tempAuxilaryValue2.get(0).longValue());  // 整
//			}
//			case 4:
//			{
//				if(!finishCalNodeSet.contains("node3"))
//				{
//					return calBinaryDiff(tempInputValue2.get(0).longValue()-2,tempAuxilaryValue2.get(1).longValue()); // 整
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 6:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1)*tempInputValue2.get(1)-8*dmin,tempAuxilaryValue2.get(2));
//			}
//			case 7:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1)*tempInputValue2.get(1)-8*dmin,tempAuxilaryValue2.get(3));
//			}
//			case 8:
//			{
//				return calBinaryDiff2(Math.abs(tempInputValue2.get(1))-tempInputValue2.get(0),tempAuxilaryValue2.get(4));
//			}
//			case 10:
//			{
//				return calBinaryDiff(1-tempInputValue2.get(0).longValue(),tempAuxilaryValue2.get(9).longValue());  // 整
//			}
//			case 11:
//			{
//				if(!isNodeInPath("node10",tpath))
//				{
//					return calBinaryDiff(1-tempInputValue2.get(0).longValue(),tempAuxilaryValue2.get(10).longValue());  // 整
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			case 12:
//			{
//				return calBinaryDiff2(Math.abs(tempInputValue2.get(1))-tempInputValue2.get(0),tempAuxilaryValue2.get(5));
//			}
//			case 13:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node20"))
//				{
//						int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));
//						return calBinaryDiff(m-tempInputValue2.get(0).longValue(),tempAuxilaryValue2.get(7).longValue());  // 整
//				}
//				else 
//				{
//					return 0;
//				}
//			}
//			case 14:
//			{
//					int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));  // 整
//					return calBinaryDiff(m,tempAuxilaryValue2.get(14).longValue());
//			}
//			case 16:
//			{
//					int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));  // 整
//					int IEXP = 512;
//					int z = (int)(Math.getExponent(m*2.0/Math.abs(tempInputValue2.get(1))))-IEXP;
//					return calBinaryDiff(z,tempAuxilaryValue2.get(6).longValue());
//			}
//			case 17:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node15"))
//				{
//						int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));
//						int IEXP = 512;
//						int z = (int)(Math.getExponent(m*2.0/Math.abs(tempInputValue2.get(1))))-IEXP;
//						return calBinaryDiff(z,tempAuxilaryValue2.get(8).longValue());   // 整
//				}
//				else 
//				{
//					return 0;
//				}
//				
//			}
//			case 21: // 整
//			{
//					int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));
////				    return calBinaryDiff2(m-tempInputValue2.get(0),0);
//				    if(m-tempInputValue2.get(0).intValue()>=0)
//				    {
//				    	return m-tempInputValue2.get(0).intValue();
//				    }
//				    else
//				    {
//				    	return -(m-tempInputValue2.get(0).intValue())+boundary;
//				    }
//			}
//			case 22: // 整
//			{
//				if(!finishCalNodeSet.contains("node14"))
//				{
//					int m = tempInputValue2.get(0).intValue()+(int)(Math.sqrt(160*tempInputValue2.get(0)));
//				    return calBinaryDiff(m,tempAuxilaryValue2.get(13).longValue());
//				}
//				else
//				{
//					return 0;
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 *  for plgndr
		 */
//		switch(number)
//		{
//			case 3:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1),tempAuxilaryValue2.get(0))*
//						calBinaryDiff2(tempInputValue2.get(1)-tempInputValue2.get(0),tempAuxilaryValue2.get(1))*
//						calBinaryDiff2(Math.abs(tempInputValue2.get(2))-1.0,tempAuxilaryValue2.get(2));
//			}
//			case 4:
//			{
//				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node2"))
//				{
//					return calBinaryDiff2(tempInputValue2.get(1),tempAuxilaryValue2.get(3))+
//							calBinaryDiff2(tempInputValue2.get(1)-tempInputValue2.get(0),tempAuxilaryValue2.get(4))+
//							calBinaryDiff2(Math.abs(tempInputValue2.get(2))-1.0,tempAuxilaryValue2.get(5));
//				}
//				else return 0;
//			}
//			case 6:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1),tempAuxilaryValue2.get(6));
//			}
//			case 8:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1)-1,tempAuxilaryValue2.get(8));
//			}
//			case 9:
//			{
//				if(getPreNodeName(tpath,node).equals("node5"))
//				{
//					return calBinaryDiff2(tempInputValue2.get(1),tempAuxilaryValue2.get(7));
//				}
//				else if(getPreNodeName(tpath,node).equals("node7")&& !isNodeInPath("node8",tpath))
//				{
//					return calBinaryDiff2(tempInputValue2.get(1)-1,tempAuxilaryValue2.get(9));
//				}
//				else return 0;
//			}
//			case 10:
//			{
//				return calBinaryDiff2(tempInputValue2.get(0)-tempInputValue2.get(1),0);
//			}
//			case 11:
//			{
//				return calBinaryDiff2(tempInputValue2.get(0)-tempInputValue2.get(1),tempAuxilaryValue2.get(10));
//			}
//			case 13:
//			{
//				return calBinaryDiff2(tempInputValue2.get(0)-tempInputValue2.get(1)-1,0);
//			}
//			case 14:
//			{
//				return calBinaryDiff2(tempInputValue2.get(0)-tempInputValue2.get(1)-1,tempAuxilaryValue2.get(11));
//			}
//			case 15:
//			{
//				return calBinaryDiff2(tempInputValue2.get(1)-tempInputValue2.get(0)+2,tempAuxilaryValue2.get(12));
//			}
//			case 16:
//			{
//				if(!isNodeInPath("node15",tpath))
//				{
//					return calBinaryDiff2(tempInputValue2.get(1)-tempInputValue2.get(0)+2,tempAuxilaryValue2.get(13));
//				}
//			}
//			default:
//			{
//				return 0;
//			}
//		}
		
		/**
		 *  for ei
		 */
		double EPS = 2.22044604925031308085e-16;
		double FPMIN = 2.22507385850720138309e-308/EPS;
		double x = tempInputValue2.get(0).doubleValue();
		switch(number)
		{
			case 3:
			{
				return calBinaryDiff2(x,tempAuxilaryValue2.get(0));
			}
			case 4:
			{
				return calBinaryDiff2(x,tempAuxilaryValue2.get(1));
			}
			case 5:
			{
				return calBinaryDiff2(x-FPMIN,tempAuxilaryValue2.get(2));
			}
			case 6:
			{
				return calBinaryDiff2(x-FPMIN,tempAuxilaryValue2.get(11));
			}
			case 7:
			{
				return calBinaryDiff2(x+Math.log(EPS),tempAuxilaryValue2.get(3));
			}
			case 8:
			{
				if(finishCalNodeSet.get(finishCalNodeSet.size()-1).equals("node10"))
				{
					return calBinaryDiff2(x,tempAuxilaryValue2.get(6));
				}
				else return 0;
			}
			case 11:
			{
					return calBinaryDiff2(x,tempAuxilaryValue2.get(5));
			}
			case 15:
			{
				return calBinaryDiff2(x+Math.log(EPS),tempAuxilaryValue2.get(4));
			}
			case 19:
			{
					return calBinaryDiff2(1/x-EPS,tempAuxilaryValue2.get(7));
			}
			case 20:
			{
					return calBinaryDiff2(1/x-EPS,tempAuxilaryValue2.get(8));
			}
			case 21:
			{
					return calBinaryDiff2(1/x-1,tempAuxilaryValue2.get(9));
			}
			case 22:
			{
					return calBinaryDiff2(1/x-1,tempAuxilaryValue2.get(10));
			}
			default:
			{
				return 0;
			}
		}
	}
	
	/**
	 * 计算两个整数的二进制表示（反码）之间的加权海明距离
	 * @param number1
	 * @param number2
	 * @return
	 */
    private static long calBinaryDiff(long number1,long number2)
    {
    	long maixExp = 1<< (leftSideLength-1);
    	/**
    	 *  当参数中有0时     
    	 */
    	if(number1 >=0 && number2 == 0)
    	{
    		return number1;
    	}
    	if(number1 <0 && number2 ==0)
    	{
    		return (-number1)+maixExp;
    	}
    	if(number2 >0 && number1 == 0)
    	{
    		return number2;
    	}
    	if(number2 <0 && number1 ==0)
    	{
    		return (-number2)+maixExp;
    	}
    	
    	/**
    	 *  当参数中没有0时  
    	 */
    	long dif = 0;
    	/* 将参数的绝对值转化为二进制串（反码）    */
    	boolean flag=true;   // 参数符号是否相同,相同为true，不同为false 
    	if(number1>0 && number2<0 ||(number1<0 && number2>0)) flag = false;
    	
    	String s1 = Long.toBinaryString(Math.abs(number1));
    	String s2 = Long.toBinaryString(Math.abs(number2));
    	int len1 = s1.length();
    	int len2 = s2.length();
    	
    	/* 对齐字符串，计算多出部分的加权海明距离    */
    	String ss1,ss2;
    	if(len1>len2)
    	{
    		String over1 = s1.substring(0, len1-len2);
    		long overValue1 = Long.parseLong(over1, 2)*(1<<len2);
    		dif += overValue1;
    		ss1 = s1.substring(len1-len2);
    		ss2 = s2;
    	}
    	else if(len1<len2)
    	{
    		String over2 = s2.substring(0, len2-len1);
    		long overValue2 = Long.parseLong(over2, 2)*(1<<len1);
    		dif += overValue2;
    		ss2 = s2.substring(len2-len1);
    		ss1 = s1;
    	}
    	else
    	{
    		ss1 = s1;
    		ss2 = s2;
    	}
    	
    	/* 计算对齐部分的加权海明距离     */
    	char[] c1 = ss1.toCharArray();
    	char[] c2 = ss2.toCharArray();
    	char[] c = c1.clone();
    	for(int i=0,size=c.length;i<size;i++)
    	{
    		c[i] = (char)(c1[i]^c2[i]-48);  // 将数字1转化为字符‘1’，数字0转化为字符‘0’
    	}
    	String diffString = new String(c);
    	dif += Long.parseLong(diffString, 2);
    	
    	/* 若参数不同号，结果需要加上符号位的权值    */
    	if(flag == false)
    	{
    		dif += maixExp;
    	}
    	
    	return dif ;
    }
    
    /**
     * 计算两个浮点数的二进制表示（反码）之间的加权海明距离
     * @param number1
     * @param number2
     * @return
     */
    private static double calBinaryDiff2(double number1,double number2)
     {
    	
    	/** 当参数含NaN或无穷时
    	 * 
    	 */
    	if(Double.isNaN(number1) || Double.isNaN(number2))
    	{
    		return Double.NaN;
    	}
    	if(Double.isInfinite(number1) || Double.isInfinite(number2))
    	{
    		return Double.POSITIVE_INFINITY;
    	}
    	
    	/**
    	 *  当参数中有0时     
    	 */
//    	double downBoundary = Math.pow(2, -rightSideLength-1);
    	double upBoundary = 1<<(leftSideLength-1);
    	if(Double.compare(number1, 0)>=0 && Double.compare(number2, 0)==0)
    	{
    		return number1;
    	}
    	if(Double.compare(number1, 0)<0 && Double.compare(number2, 0)==0)
    	{
    		return (-number1) + upBoundary;
    	}
    	if(Double.compare(number1, 0)==0 && Double.compare(number2, 0)>=0)
    	{
    		return number2;
    	}
    	if(Double.compare(number1, 0)==0 && Double.compare(number2, 0)<0)
    	{
    		return (-number2) + upBoundary;
    	}
    	
    	/**
    	 *  当参数不为0 
    	 */
    	double dif = 0;
    	boolean flag = true;   // 参数符号是否相同,相同为true，不同为false
    	/* 将参数转化为16进制串                */
    	String hexString1 = Double.toHexString(number1);
    	String hexString2 = Double.toHexString(number2);
    	/* 判断2个参数的符号是否相同    */
    	if(hexString1.charAt(0)!= hexString2.charAt(0))
    	{
    		flag = false;
    	}
    	/* 忽略小数点和幂，将16进制串转化为二进制串（例如，将 0x1.12p3 的16进制串112转化为100010010      */
    	int indexOfX1 = hexString1.indexOf('x');
    	int indexOfPoint1 = hexString1.indexOf('.');
    	int indexOfP1 = hexString1.indexOf('p');
    	char char1 = hexString1.charAt(indexOfX1+1);
    	String subString1 = hexString1.substring(indexOfPoint1+1, indexOfP1);
    	StringBuffer sb1 = new StringBuffer(14);
    	String hexString11 = sb1.append(1).append(subString1).toString();
    	
    	int indexOfX2 = hexString2.indexOf('x');
    	int indexOfPoint2 = hexString2.indexOf('.');
    	int indexOfP2 = hexString2.indexOf('p');
    	char char2 = hexString2.charAt(indexOfX2+1);
    	String subString2 = hexString2.substring(indexOfPoint2+1, indexOfP2);
    	StringBuffer sb2 = new StringBuffer(14);
    	String hexString22 = sb2.append(1).append(subString2).toString();
    	
    	long l1 = Long.parseLong(hexString11, 16);
    	long l2 = Long.parseLong(hexString22, 16);
    	String tempString1 = Long.toBinaryString(l1);
    	String tempString2 = Long.toBinaryString(l2);
    	StringBuffer bsb1 = new StringBuffer(tempString1);
    	bsb1.setCharAt(0, char1);
    	String binString1 = bsb1.toString();
    	StringBuffer bsb2 = new StringBuffer(tempString2);
    	bsb1.setCharAt(0, char2);
    	String binString2 = bsb2.toString();
    	
    	/* 确定二进制串的幂      */
    	String expStr1 = hexString1.substring(indexOfP1+1);
    	String expStr2 = hexString2.substring(indexOfP2+1);
    	int tempExp1 = Integer.parseInt(expStr1);
    	int tempExp2 = Integer.parseInt(expStr2);
    	int exp1 = tempExp1-(indexOfP1-indexOfPoint1-1)*4;  // 根据小数点位置修正幂
    	int exp2 = tempExp2-(indexOfP2-indexOfPoint2-1)*4;
    	
       /* 计算整数部分的海明距离    */
    	dif += calBinaryWHD(binString1,exp1,binString2,exp2);
    	
    	/* 计算小数部分的海明距离    */
    	dif += calPoinBinaryWHD(binString1,tempExp1,binString2,tempExp2);
    	
    	/* 根据符号位标志修正最终结果   */
    	if(flag == false)
    	{
    		dif+= upBoundary;
    	}
    	return dif;
    }
	
    /**
     * 计算两个表示浮点数的二进制串的整数部分的加权海明距离,第一个串为 s10...0 (e1个0） ， 第二个串为 s20...0 (e2个0）,注意这里 s1,s2必须只由0或1组成
     * @param s1: h0b1b2...b(4*k1), k1<=13, h0,bi为0或1
     * @param e1: 
     * @param s2: H0B1B2...B(4*k2), k2<=13，H0，Bj为0或1
     * @param e2: 
     * @return
     */
    private static double calBinaryWHD(String s1,int e1,String s2,int e2)
    {
    	double whd = 0.0;
    	int len1 = s1.length();
    	int len2 = s2.length();
    	int d;
    	double exp1 = Math.pow(2, e1);
    	double exp2 = Math.pow(2, e2);
    	double exp3 = Math.pow(2, e2+len2);
    	double valueofs1 = (double)Long.parseLong(s1, 2);
    	double valueofs2 = (double)Long.parseLong(s2, 2);
    	/**
    	 *  当浮点数的整数部分都为0
    	 */
    	if(len1+e1<=0 && len2+e2<=0)
    	{
    		return 0;
    	}
    	
    	/**
    	 *  当一个浮点数的整数部分为0，另一个不为0
    	 */
    	else if(len1+e1>0 && len2+e2<=0)
    	{
    		if(e1>=0)  //第一个浮点数的整数部分包含s1 
    		{
    			return valueofs1*exp1;
    		}
    		else  //第一个浮点数的整数部分包含s1的子串 h0b1b2...b(len1+e1-1) 
    		{
    			String ps1 = s1.substring(0, len1+e1);
    			return (double)Long.parseLong(ps1, 2);
    		}
    	}
    	else if(len1+e1<=0 && len2+e2>0)
    	{
    		if(e2>=0)  //第二个浮点数的整数部分包含s2 
    		{
    			return valueofs2*exp2;
    		}
    		else  //第二个浮点数的整数部分包含s2的子串 H0B1B2...B(len2+e2-1) 
    		{
    			String ps2 = s2.substring(0, len2+e2);
    			return (double)Long.parseLong(ps2, 2);
    		}
    	}
    	
    	/** 
    	 *  当两个浮点数的整数部分都不为0
    	 *  首先比较两个串的长度，计算出长串多出部分的海明距离，再对剩余字符串进行异或运算，得差异字符串，结合幂，计算出对齐部分的海明距离。
    	 *  将两部分的海明距离相加，得到最终结果    
    	 */  
    	else if(len1+e1>len2+e2 ) // len1+e1>0 && len2+e2>0
    	{
    		d = len1+e1-len2-e2;
    		/* 多出部分在s1中    */
    		if(d<=len1 && e2>=0 && e1>=0)  // 第一个浮点数的整数部分包含s1，第二个浮点数的整数部分包含s2
    		{
    			/**
    			 * 计算多出部分的海明距离
    			 */
    			String ps1 = s1.substring(0,d);    // 多处部分字符串              
    			whd += ((double)Long.parseLong(ps1, 2)*exp3);  // 加上多出部分的海明距离
    			
    			/**
    			 * 计算对齐部分的海明距离
    			 */
    			String left1 = s1.substring(d);   // 剩余字符串
    			int leftlen1 = left1.length();
    			
    			/* 将字符串转化为字符数组     */
    			char[] c1 = left1.toCharArray();
    			char[] c2 = s2.toCharArray();
    			
    			/* 构造异或字符串，结合幂，计算出对齐部分的海明距离   */
    			if(leftlen1 >= len2)
    			{
    				char[] c = c1.clone();
    				for(int i=0,size=c2.length;i<size;i++)
    				{
    					c[i]= (char)(c1[i]^c2[i]-48);
    				}
    				String  xorStr = new String(c);  // 异或字符串
    				whd += ((double)Long.parseLong(xorStr, 2)*exp1);  // 加上对齐部分的海明距离
    			}
    			else 
    			{
    				char[] c = c2.clone();
    				for(int i=0,size=c1.length;i<size;i++)
    				{
    					c[i]= (char)(c1[i]^c2[i]-48);
    				}
    				String  xorStr = new String(c);  // 异或字符串
    				whd += ((double)Long.parseLong(xorStr, 2)*exp2);  // 加上对齐部分的海明距离
    			}
    		} //if(d <= len1)
    		else if(d<=len1 && e1>=0 && e2<0) //第一个浮点数的整数部分包含s1，第二个浮点数的整数部分包含s2的子串 H0B1B2...B(len2+e2-1)
    		{
    			
    			/**
    			 * 计算多出部分的海明距离
    			 */
    			String ps1 = s1.substring(0,d);    // 多处部分字符串              
    			whd += ((double)Long.parseLong(ps1, 2)*exp3);  // 加上多出部分的海明距离
    			
    			/**
    			 * 计算对齐部分的海明距离
    			 */
    			String left1 = s1.substring(d);   // 剩余字符串
    			String ps2 = s2.substring(0, len2+e2);
    			int leftlen1 = left1.length();
    			
    			/* 将字符串转化为字符数组     */
    			char[] c1 = left1.toCharArray();
    			char[] c2 = ps2.toCharArray();
    			
    			/* 构造异或字符串，结合幂，计算出对齐部分的海明距离   */
				char[] c = c2.clone();
				for(int i=0,size=c1.length;i<size;i++)
				{
					c[i]= (char)(c1[i]^c2[i]-48);
				}
				String  xorStr = new String(c);  // 异或字符串
				whd += ((double)Long.parseLong(xorStr, 2));  // 加上对齐部分的海明距离
    		}
    		else if(d<=len1 && e1<0 && e2>=0) //第一个浮点数的整数部分包含s1的子串 h0b1b2...b(len1+e1-1)，第二个浮点数的整数部分包含s2
    		{
    			/**
    			 *  计算多出部分的海明距离
    			 */
    			String ps1 = s1.substring(0,d);
    			whd += ((double)Long.parseLong(ps1, 2)*exp3);  // 加上多出部分的海明距离
    			
    			/**
    			 *  计算对齐部分的海明距离
    			 */
    			String left1 = s1.substring(d,len1+e1);
    			int leftlen1 = left1.length();
    			/* 将字符串转化为字符数组     */
    			char[] c1 = left1.toCharArray();
    			char[] c2 = s2.toCharArray();
    			
    			/* 构造异或字符串，结合幂，计算出对齐部分的海明距离   */
				char[] c = c1.clone();
				for(int i=0,size=c2.length;i<size;i++)
				{
					c[i]= (char)(c1[i]^c2[i]-48);
				}
				String  xorStr = new String(c);  // 异或字符串
				whd += ((double)Long.parseLong(xorStr, 2));  // 加上对齐部分的海明距离
    		}
    		else if(d<=len1 && e1<0 && e2<0) //第一个浮点数的整数部分包含s1的子串 h0b1b2...b(len1+e1-1)，第二个浮点数的整数部分包含s2的子串 H0B1B2...B(len2+e2-1)
    		{
    			// 由于两个浮点数的整数部分的长度都小于64，故可直接计算加权海明距离
    			char[] c1 = s1.substring(0, len1+e1).toCharArray();
    			char[] c2 = s2.substring(0, len2+e2).toCharArray();
    			char[] c = c1.clone();
    			for(int i=d,size=c1.length;i<size;i++)
    			{
    				c[i] = (char)(c1[i]^c2[i-d]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2));
    		}
    		else if(d > len1 && e2>=0) // e1必>0
    		{
    			/**
    			 *  计算多出部分的海明距离   
    			 */
    			whd += ((double)Long.parseLong(s1, 2)*(1<<(d-len1))*exp3);  // 加上多出部分的海明距离
    			
    			/**
    			 *  计算对齐部分的海明距离
    			 */
    			whd += ((double)Long.parseLong(s2, 2)*exp2);  // 加上对齐部分的海明距离
    		}
    		else // d>len1 && e2<0
    		{
    			/**
    			 *  计算多出部分的海明距离   
    			 */
    			whd += ((double)Long.parseLong(s1, 2)*(1<<(d-len1))*exp3);  // 加上多出部分的海明距离
    			
    			/**
    			 *  计算对齐部分的海明距离
    			 */
    			String ps2 = s2.substring(0, len2+e2);
    			whd += ((double)Long.parseLong(ps2, 2));  // 加上对齐部分的海明距离
    		}
    	} //if(len1+e1 > len2+e2)
    	else if(len1+e1 == len2+e2)  // 没有多出部分
    	{
    		/**
    		 *  计算对齐部分的海明距离
    		 */
    		if(len1 >= len2 && e1>=0 && e2>=0) // 第一个浮点数的整数部分包含s1，第二个浮点数的整数部分包含s2
    		{
    			char[] c1 = s1.toCharArray();
    			char[] c2 = s2.toCharArray();
    			char[] c =c1.clone();
    			for(int i=0,size=c2.length;i<size;i++)
    			{
    				c[i]=(char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2)*exp1);  // 加上对齐部分的海明距离
    		}
//    		else if(len1 >= len2 && e1>=0 && e2<0) //空集
    		else if(len1 >= len2 && e1<0 && e2>=0) //第一个浮点数的整数部分包含s1的子串 h0b1b2...b(len1+e1-1)，第二个浮点数的整数部分包含s2
    		{
    			// 由于两个浮点数的整数部分的长度都小于64，故可直接计算加权海明距离
    			char[] c1 = s1.substring(0, len1+e1).toCharArray();
    			char[] c2 = s2.toCharArray();
    			char[] c = c1.clone();
    			for(int i=0,size=c2.length;i<size;i++)
    			{
    				c[i] = (char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2));
    		}
    		else if(len1 >= len2 && e1<0 && e2<0) //第一个浮点数的整数部分包含s1的子串 h0b1b2...b(len1+e1-1)，第二个浮点数的整数部分包含s2的子串 H0B1B2...B(len2+e2-1)
    		{
    			// 由于两个浮点数的整数部分的长度都小于64，故可直接计算加权海明距离
    			char[] c1 = s1.substring(0, len1+e1).toCharArray();
    			char[] c2 = s2.substring(0, len2+e2).toCharArray();
    			char[] c = c1.clone();
    			for(int i=0,size=c1.length;i<size;i++)
    			{
    				c[i] = (char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2));
    		}
    		else if(len1<len2 && e1>=0 && e2>=0)
    		{
    			char[] c1 = s1.toCharArray();
    			char[] c2 = s2.toCharArray();
    			char[] c =c2.clone();
    			for(int i=0,size=c1.length;i<size;i++)
    			{
    				c[i]=(char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2)*exp2);  // 加上对齐部分的海明距离
    		}
//    		else if(len1<len2 && e1<0 && e2>=0) // 空集
    		else if(len1<len2 && e1>=0 && e2<0)
    		{
    			// 由于两个浮点数的整数部分的长度都小于64，故可直接计算加权海明距离
    			char[] c1 = s1.toCharArray();
    			char[] c2 = s2.substring(0, len2+e2).toCharArray();
    			char[] c = c2.clone();
    			for(int i=0,size=c1.length;i<size;i++)
    			{
    				c[i] = (char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2));
    		}
    		else // len1<len2 && e1<0 && e2<0
    		{
    			// 由于两个浮点数的整数部分的长度都小于64，故可直接计算加权海明距离
    			char[] c1 = s1.substring(0, len1+e1).toCharArray();
    			char[] c2 = s2.substring(0, len2+e2).toCharArray();
    			char[] c = c1.clone();
    			for(int i=0,size=c1.length;i<size;i++)
    			{
    				c[i] = (char)(c1[i]^c2[i]-48);
    			}
    			String xorStr = new String(c);
    			whd += ((double)Long.parseLong(xorStr, 2));
    		}
    	}// else if(len1+e1 == len2+e2)
    	else // (len1+e1 < len2+e2)
    	{
    		return calBinaryWHD(s2, e2, s1, e1);
    	} 
    	return whd;
    }
    
    /**
     * 计算两个表示浮点数的二进制串的小数部分之间的加权海明距离
     * 第一个小数为 s1*2^(s1.length-1-y1), 第二个小数为 s2*2^(s2.length-1-y2), 
     * 这里s1、s2必须只由0或1组成，长度均不大于53且模4余1
     * @param s1: ="h0b1b2b3...b(4*k1)" , h0,bi (1<=i<=4*k1)为字符0或1 
     * @param y1: 
     * @param s2: ="H0B1B2B3...B(4*k2)" , H0,Bj (1<=j<=4*k2)为字符0或1
     * @param y2: 
     * @return
     */
    private static double calPoinBinaryWHD(String s1,int y1,String s2,int y2)
    {
    	double whd = 0.0;
    	int len1 = s1.length(); // len1%4 =1
    	int len2 = s2.length();
    	int minus1 = len1-1-y1;
    	int minus2 = len2-1-y2;
    	double exp1 = Math.pow(2, -minus1);
    	double exp2 = Math.pow(2, -minus2);
    	
    	/**
    	 *  小数部分均为0   
    	 */  
    	if(minus1<=0 && minus2<=0)
    	{
    		return 0;
    	}
    	
    	/**
    	 *  一个浮点数的小数部分为0，另一个不为0
    	 */
    	else if(minus1>0 && minus2<=0)
    	{
    		if(0<=y1 && y1<len1-1)  // 此时 第一个浮点数为 h0b1b2...by1 . b(y1+1)b(y1+2)...b(4*k1), 小数部分为  0.b(y1+1)b(y1+2)...b(4*k1)
    		{
    			String ps1 = s1.substring(y1+1);
    			return (double)Long.parseLong(ps1, 2)*exp1;
    		}
    		else // y1<0, 此时 第一个浮点数为 0.h0b1b2...b(4*k1)  * 2^(y1+1), 小数部分为 0.00...0h0b1b2...b(4*k1)  ,小数点和h0之间共 -(y1+1)个0
    		{
    			return (double)Long.parseLong(s1, 2)*exp2;
    		}
    	}
    	
    	else if(minus1<=0 && minus2>0)
    	{
    		if(0<=y2 && y2<len2-1)  // 此时 第二个浮点数为 H0B1B2...By2 . B(y2+1)B(y2+2)...B(4*k2), 小数部分为  0.B(y2+1)B(y2+2)...B(4*k2)
    		{
    			String ps2 = s2.substring(y2+1);
    			return (double)Long.parseLong(ps2, 2)*exp2;
    		}
    		else // y2<0, 此时 第二个浮点数为 0.H0B1B2...B(4*k2)  * 2^(y2+1), 小数部分为 0.00...0H0B1B2...B(4*k2)  ,小数点和B0之间共 -(y2+1)个0
    		{
    			return (double)Long.parseLong(s2, 2)*exp2;
    		}
    	}
    	
    	/**
    	 *  小数部分均不为0, 先将小数部分对齐，计算长串多出部分的加权海明距离，再计算对齐部分的海明距离，二者相加得最终结果
    	 */
    	else  //  	(len1-1-y1>0 && len2-1-y2>0)
    	{
    		if(minus1 > minus2)
    		{
    			
    			int d = minus1-minus2;   // 多出部分的长度
    			if(d >= len1) // 多出部分包含s1
    			{
    				/**
        			 *  计算多出部分的加权海明距离
        			 */
    				whd += (double)Long.parseLong(s1, 2)*exp1;   // 加上多出部分的海明距离
    				
    				/**
        			 *  计算对齐部分的加权海明距离
        			 */
    				if(minus2 >= len2)  // 第二个浮点数的小数部分包含s2
    				{
    					whd += (double)Long.parseLong(s2, 2)*exp2;   // 加上对齐部分的海明距离
    				}
    				else // 第二个浮点数的小数部分包含s2的子串， B(1+y2)B(2+y2)...B(4*k2)
    				{
    					String ps2 = s2.substring(1+y2);
    					whd += (double)Long.parseLong(ps2, 2)*exp2;   // 加上对齐部分的海明距离
    				}
        			
    			} //if(d >= len1)
    			else   // d<len1 多出部分包含s1的子串 b(4*k1-d+1)b(4*k1-d+2)...b(4*k1)
    			{
    				String ps1 = s1.substring(len1-d);
    				String left1 = s1.substring(0, len1-d);
    				
    				/**
        			 *  计算多出部分的加权海明距离
        			 */
    				whd += (double)Long.parseLong(ps1, 2)*exp1;   // 加上多出部分的海明距离
    				
    				/**
        			 *  计算对齐部分的加权海明距离
        			 */
    				if(minus1 >= len1 && minus2 >= len2) // 第一个浮点的小数部分包含s1, 第二个浮点数的小数部分包含s2
    				{
    					if(len1-d >= len2 )
        				{
        					char[] c1 = left1.toCharArray();
        					char[] c2 = s2.toCharArray();
        					char[] c = c1.clone();
        					
        					for(int i=len1-d-len2,offset=len1-d-len2,size=len1-d;i<size;i++)
        					{
        						c[i]=(char)(c1[i]^c2[i-offset]-48);
        					}
        					String xorStr = new String(c);
                			whd += (double)Long.parseLong(xorStr, 2)*exp2;  // 加上对齐部分的海明距离
        				}
        				else
        				{
        					char[] c1 = left1.toCharArray();
        					char[] c2 = s2.toCharArray();
        					char[] c = c2.clone();
        					
        					for(int i=len2-(len1-d),offset=len2-(len1-d);i<len2;i++)
        					{
        						c[i]=(char)(c1[i-offset]^c2[i]-48);
        					}
        					String xorStr = new String(c);
                			whd += (double)Long.parseLong(xorStr, 2)*exp2;  // 加上对齐部分的海明距离
        				}
    				}
    				else if(minus1 >= len1 && minus2 < len2) // 第一个浮点的小数部分包含s1, 第二个浮点数的小数部分包含s2的子串 B(1+y2)B(2+y2)...B(4*k2)
    				{
    					String ps2 = s2.substring(1+y2);
    					if(len1-d < len2)
    					{
    						char[] c1 = left1.toCharArray();
    						char[] c2 = ps2.toCharArray();
    						char[] c = c2.clone();
    						for(int i=c2.length-c1.length,offset=1+y1,size=c2.length;i<size;i++)  // c2.length-c1.length = len2-1-y2 - (len1-d) = -1-y1
    						{
    							c[i] = (char)(c1[i+offset]^c2[i]-48);
    						}
    						String xorStr = new String(c);
    						whd += (double)Long.parseLong(xorStr, 2)*exp2;  // 加上对齐部分的海明距离
    					}
    					// if( len1 -d >= len2) 为空集
    				}
    				else if(minus1 < len1 && minus2 >= len2) // 第一个浮点数的小数部分包含s1的子串 b(1+y1)b(2+y1)...b(4*k1), 第二个浮点的小数部分包含s2,
    				{
    					String pleft1 = left1.substring(1+y1);
    					if(len1-d >= len2)
    					{
    						char[] c1 = pleft1.toCharArray();
    						char[] c2 = s2.toCharArray();
    						char[] c = c1.clone();
    						for(int i=c1.length-c2.length,offset=1+y2,size=c1.length;i<c1.length;i++) // c1.length-c2.length = len1-d-(1+y1) - len2 = -1-y2
    						{
    							c[i] = (char)(c1[i]^c2[i+offset]-48);
    						}
    						String xorStr = new String(c);
    						whd += (double)Long.parseLong(xorStr, 2)*exp2;  // 加上对齐部分的海明距离
    					}
    					// if(len1-d < len2) 为空集
    				}
    				else // (len1-1-y1<len1 && len2-1-y2<len2)  第一个浮点数的小数部分包含s1的子串 b(1+y1)b(2+y1)...b(4*k1)，第二个浮点数的小数部分包含s2的子串 B(1+y2)B(2+y2)...B(4*k2)
    				{
    					String pleft1 = left1.substring(1+y1);
    					String ps2 = s2.substring(1+y2);
    					char[] c1 = pleft1.toCharArray();
    					char[] c2 = ps2.toCharArray();
    					char[] c = c1.clone();
    					for(int i=0,size=c.length;i<size;i++)
    					{
    						c[i] = (char)(c1[i]^c2[i]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp2;  // 加上对齐部分的海明距离
    				}
    			}
    			
    			
    		}// if(len1-1-y1 > len2-1-y2)
    		else if(minus1 == minus2)
    		{
    			
    			if(minus1 >= len1) // 小数部分包含s1
    			{
    				if(len1<=len2 && len2<= minus1) // 小数部分包含s2, s2长度大于等于s1
    				{
    					/**
    	    			 *  计算对齐部分的加权海明距离
    	    			 */
    					char[] c1 = s1.toCharArray();
    					char[] c2 = s2.toCharArray();
    					char[] c = c2.clone();
    					for(int i=len2-len1,offset=-(len2-len1);i<len2;i++)
    					{
    						c[i] = (char)(c1[i+offset]^c2[i]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp1; // 加上对齐部分的海明距离
    				}
    				else if(len2<len1)// 小数部分包含s2, s2长度小于s1
    				{
    					/**
    	    			 *  计算对齐部分的加权海明距离
    	    			 */
    					char[] c1 = s1.toCharArray();
    					char[] c2 = s2.toCharArray();
    					char[] c = c1.clone();
    					for(int i=len1-len2,offset=-(len1-len2);i<len1;i++)
    					{
    						c[i] = (char)(c1[i]^c2[i+offset]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp1; // 加上对齐部分的海明距离
    				}
    				else // len2 > len1-1-y1, 小数部分包含 s2的子串 BxB(x+1)...B(4*k2), x满足 4*k2-x+1 = len1-1-y1, 及 len2-x = len2-1-y2, 得x=1+y2
    				{
    					/**
    	    			 *  计算对齐部分的加权海明距离
    	    			 */
    					String ps2 = s2.substring(1+y2);
    					char[] c1 = s1.toCharArray();
    					char[] c2 = ps2.toCharArray();
    					char[] c = c2.clone();
    					for(int i=minus1-len1,offset=-(minus1-len1),size=c.length;i<size;i++)
    					{
    						c[i] = (char)(c1[i+offset]^c2[i]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp1; // 加上对齐部分的海明距离
    				}
    			} //if(len1-1-y1 >= len1)
    			else // len1 > len1-1-y1, 小数部分包含 s1的子串 bxb(x+1)...b(4*k1), x满足 4*k1-x+1 = len1-1-y1, 及 len1-x = len1-1-y1, 得x=1+y1
    			{
    				if(len2<=minus1)  // 小数部分包含 s2
    				{
    					/**
    	    			 *  计算对齐部分的加权海明距离
    	    			 */
    					String ps1 = s1.substring(1+y1);
    					char[] c1 = ps1.toCharArray();
    					char[] c2 = s2.toCharArray();
    					char[] c = c1.clone();
    					for(int i=minus1-len2,offset=-(minus1-len2),size=c.length;i<size;i++)
    					{
    						c[i] = (char)(c1[i]^c2[i+offset]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp1; // 加上对齐部分的海明距离
    				}
    				else// len2 > len1-1-y1, 小数部分包含 s2的子串 BxB(x+1)...B(4*k2), x满足 4*k2-x+1 = len1-1-y1, 及 len2-x = len2-1-y2, 得x=1+y2
    				{
    					/**
    	    			 *  计算对齐部分的加权海明距离
    	    			 */
    					String ps1 = s1.substring(1+y1);
    					String ps2 = s2.substring(1+y2);
    					char[] c1 = ps1.toCharArray();
    					char[] c2 = ps2.toCharArray();
    					char[] c = c2.clone();
    					for(int i=0,size=c.length;i<size;i++)
    					{
    						c[i] = (char)(c1[i]^c2[i]-48);
    					}
    					String xorStr = new String(c);
    					whd += (double)Long.parseLong(xorStr, 2)*exp1; // 加上对齐部分的海明距离
    				}
    			}
    		} //else if(len1-1-y1 == len2-1-y2)
    		else // len1-1-y1 < len2-1-y2
    		{
    			return calPoinBinaryWHD( s2,y2,s1,y1);
    		}
    	}
    	return whd;
    }
	
	/**
	 * 对整型输入的配置进行扰动,从行参和辅助变量中选取某一个，
	 * 改变其二进制表示的某一位的值，是0改为1，是1改为0,结果保存在临时配置（及其二进制表示数组）中
	 */
	private static void perturbation()
	{  
//		 ss++;
		int totalCount = inputCount + auxilaryCount;
		int bitValue;  // 位值
		long value;  // 变量值，0或1
		long deta;   // 变化量
		int firstBitValue;  // 首位值
		long maxiExp = 1<<(leftSideLen-1);
		 
		/**
		 *  以下这些变量是为了加快程序的运行速度而设立的,它们替代了程序中重复出现的变量
		 */
		int indexC;  // 扰动变量在列表中的实际位置
		int[] arrayC;  // 扰动后实际发生改变的数组
		List<Long> listC; //扰动后发生改变的列表
		long restoreValue;  // 还原值
		Random rd = new Random();
		Integer in;

		
		/**
		 *  还原临时配置为现有配置
		*/
		if(flag==false) // flag标记最近一次扰动是否被接受
		{
			if(changeVari <= inputCount)    // 最近一次扰动发生在临时输入变量
			{
				indexC = changeVari-1;
				arrayC  = tempInputBits.get(indexC);
				listC = tempInputValue;
				restoreValue = inputValue.get(indexC);
			}
			else  // 最近一次扰动发生在临时辅助变量
			{
				indexC = changeVari-inputCount-1;
				arrayC = tempAuxilaryBits.get(indexC);
				listC = tempAuxilaryValue;
				restoreValue = auxilaryValue.get(indexC);
			}
			
			bitValue = arrayC[changeBit];
			arrayC[changeBit] = 1-bitValue;   
		   listC.set(indexC, restoreValue);  
		}
		
		/** || 对配置进行扰动，结果保存在临时配置（及其二进制表示数组）中,           ||
		 *  ||注意扰动结果必须满足变量约束（如有些变量必须为正值、辅助变量不能为0等||
		    || || || || || || || || || || || || || || || || || || || || || || || ||
		    */
		
		
		/**
		 *  确定扰动变量   
		 */  
		changeVari = rd.nextInt(totalCount)+1; // 选取改变的变量的位置
		in = new Integer(changeVari); 
		
		while(!perturRangeSet.contains(in))// 确保扰动变量在扰动范围中
		{
			changeVari = rd.nextInt(totalCount)+1;
			in = new Integer(changeVari); 
		}
		
		/** 
		 * 初始化只与扰动变量有关的变量
		 **/ 
		if(changeVari <= inputCount)
		{
			indexC = changeVari-1;
			arrayC = null;  // 释放内存
			arrayC = tempInputBits.get(indexC);
			listC = null;  // 释放内存
			listC = tempInputValue;
		}
		else
		{
			indexC = changeVari-1-inputCount;
			arrayC = null;  // 释放内存
			arrayC = tempAuxilaryBits.get(indexC);
			listC = null;  // 释放内存
			listC = tempAuxilaryValue;
		}
		value = listC.get(indexC).longValue();
		firstBitValue = arrayC[0];
		
		
		/**
		 *  确定扰动位 
		 */
		if(!positiveSet.contains(in) &&
				!negativeSet.contains(in) &&
				     !unPositiveSet.contains(in) &&
				           !unNegativeSet.contains(in) &&
				               !unZeroSet.contains(in) ) // 扰动变量没有值域约束，可以为任何值
		{
			changeBit = rd.nextInt(len);
		}
		else if(positiveSet.contains(in) )   // 扰动变量满足正约束
		{
			changeBit = rd.nextInt(len);
			
			bitValue = arrayC[changeBit];
			deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
			while(changeBit == 0 ||  ((1-2*bitValue)*deta+value==0))  // 确保扰动会变量仍为正值
			{
				changeBit = rd.nextInt(len);
				bitValue = arrayC[changeBit];
				deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLen-1-changeBit)
			}
		}
		else if(unNegativeSet.contains(in))  // 扰动变量满足非负约束
		{
			changeBit = rd.nextInt(len);
			 
			while(changeBit == 0 )  // 确保扰动会变量仍非负
			{
				changeBit = rd.nextInt(len);
			}
		}
		else if(negativeSet.contains(in))// 扰动变量满足负约束
		{
			changeBit = rd.nextInt(len);
			bitValue= arrayC[changeBit];
			deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
			while(changeBit == 0 ||  (-(1-2*bitValue)*deta+value==0))  // 确保扰动会变量仍为负值
			{
				changeBit = rd.nextInt(len);
				bitValue= arrayC[changeBit];
				deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
			}
		}
		else if(unPositiveSet.contains(in))// 扰动变量满足非正约束
		{
			changeBit = rd.nextInt(len);
			 
			while(changeBit == 0 )  // 确保扰动会变量仍非正
			{
				changeBit = rd.nextInt(len);
			}
		} 
		else    // unZeroSet.contains((new Integer(changeVari)) 即扰动变量满足非0约束
		{
			changeBit = rd.nextInt(len);
			 
			bitValue= arrayC[changeBit];
			deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
			
			if(changeBit !=0)
			{
				while((1-2*firstBitValue)*(1-2*bitValue)*deta+value == 0)   // 当变量扰动后值为0
				{
					changeBit = rd.nextInt(len);
					bitValue= arrayC[changeBit];
					deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
				}
			}
		}
		
		/**
		 *  扰动
		 */
		deta = maxiExp>>changeBit;  // deta = Math.pow(2,leftSideLength-1-changeBit)
		bitValue = arrayC[changeBit];
		Long v1 = new Long(value+deta);
		Long v2 = new Long(value-deta);
		Long v3 = new Long(-value);
		
		arrayC[changeBit] = 1-bitValue;
		if(changeBit != 0)
    	 {
    		 if(bitValue == 0 && firstBitValue==0)
	    	 {
		    	 listC.set(indexC,v1);
	    	 }
	    	 else if(bitValue ==0 && firstBitValue==1)
	    	 {
	    		 listC.set(indexC,v2);
	    	 }
	    	 else if(bitValue ==1 && firstBitValue==0)
	    	 {
	    		 listC.set(indexC,v2);
	    	 }
	    	 else
	    	 {
	    		 listC.set(indexC,v1);
	    	 }
    	 }
    	 else // changeBit == 0,此时deta没有意义
    	 {
    		 listC.set(indexC,v3);
    	 }
	}
	
	
	/**
	 * 对浮点型或混合型输入的配置进行扰动,从行参和辅助变量中选取某一个，
	 * 改变其二进制表示的某一位的值，是0改为1，是1改为0,结果保存在临时配置（及其二进制表示数组）中
	 */
	private static void perturbation2()
	{  
//      ss++;
		int totalCount = inputCount + auxilaryCount;
		int bitValue;  // 位值
		double value;  // 变量值，0或1
		double deta;   // 变化量
		int firstBitValue;  // 首位值
		
		/**
		 *  以下这些变量是为了加快程序的运行速度而设立的,它们替代了程序中重复出现的变量
		 */
		int indexC;  // 扰动变量在列表中的实际位置
		int[] arrayC;  // 扰动后实际发生改变的数组
		List<Double> listC; //扰动后发生改变的列表
		Double restoreValue;  // 还原值
		Random rd = new Random();
		Integer in;
		int randomUpBoundary;  // 产生随机数的上限

		
		/**
		 *  还原临时配置为现有配置
		*/
		if(flag==false) // flag标记最近一次扰动是否被接受
		{
			if(changeVari <= inputCount)    // 最近一次扰动发生在临时输入变量
			{
				indexC = changeVari-1;
				arrayC  = tempInputBits2.get(indexC);
				listC = tempInputValue2;
				restoreValue = inputValue2.get(indexC);
			}
			else  // 最近一次扰动发生在临时辅助变量
			{
				indexC = changeVari-inputCount-1;
				arrayC = tempAuxilaryBits2.get(indexC);
				listC = tempAuxilaryValue2;
				restoreValue = auxilaryValue2.get(indexC);
			}
			
			bitValue = arrayC[changeBit];
			arrayC[changeBit] = 1-bitValue;   
		   listC.set(indexC, restoreValue);  
		}
		
		/** || 对配置进行扰动，结果保存在临时配置（及其二进制表示数组）中,           ||
		 *  ||注意扰动结果必须满足变量约束（如有些变量必须为正值、辅助变量不能为0等||
		    || || || || || || || || || || || || || || || || || || || || || || || ||
		    */
		
		
		/**
		 *  确定扰动变量   
		 */  
		changeVari = rd.nextInt(totalCount)+1; // 选取改变的变量的位置
		in = new Integer(changeVari); 
		
		while(!perturRangeSet.contains(in))// 确保扰动变量在扰动范围中
		{
			changeVari = rd.nextInt(totalCount)+1;
			in = new Integer(changeVari); 
		}
		
		/** 
		 * 初始化只与扰动变量有关的变量
		 **/ 
		if(changeVari <= inputCount)
		{
			indexC = changeVari-1;
			arrayC = null;  // 释放内存
			arrayC = tempInputBits2.get(indexC);
			listC = null;  // 释放内存
			listC = tempInputValue2;
		}
		else
		{
			indexC = changeVari-1-inputCount;
			arrayC = null;  // 释放内存
			arrayC = tempAuxilaryBits2.get(indexC);
			listC = null;  // 释放内存
			listC = tempAuxilaryValue2;
		}
		value = listC.get(indexC).doubleValue();
		firstBitValue = arrayC[0];
		/* 当变量必须为整数时,确保扰动发生在整数部分     */
		if(intSet.contains(in))
		{
			randomUpBoundary = leftSideLen;
		}
		else
		{
			randomUpBoundary = len;
		}
		
		
		/**
		 *  确定扰动位 
		 */
		if(!positiveSet.contains(in) &&
				!negativeSet.contains(in) &&
				     !unPositiveSet.contains(in) &&
				           !unNegativeSet.contains(in) &&
				               !unZeroSet.contains(in) ) // 扰动变量没有值域约束，可以为任何值
		{
			changeBit = rd.nextInt(randomUpBoundary);
		}
		else if(positiveSet.contains(in) )   // 扰动变量满足正约束
		{
			changeBit = rd.nextInt(randomUpBoundary);
			
			bitValue = arrayC[changeBit];
			deta = Math.pow(2,leftSideLen-1-changeBit);
			while(changeBit == 0 ||  Double.compare(0,(1-2*bitValue)*deta+value)>=0)  // 确保扰动会变量仍为正值
			{
				changeBit = rd.nextInt(randomUpBoundary);
				bitValue = arrayC[changeBit];
				deta = Math.pow(2,leftSideLen-1-changeBit);
			}
		}
		else if(unNegativeSet.contains(in))  // 扰动变量满足非负约束
		{
			changeBit = rd.nextInt(randomUpBoundary);
			 
			while(changeBit == 0 )  // 确保扰动会变量仍非负
			{
				changeBit = rd.nextInt(randomUpBoundary);
			}
		}
		else if(negativeSet.contains(in))// 扰动变量满足负约束
		{
			changeBit = rd.nextInt(randomUpBoundary);
			bitValue= arrayC[changeBit];
			deta = Math.pow(2,leftSideLen-1-changeBit);
			while(changeBit == 0 ||  Double.compare(0, -(1-2*bitValue)*deta+value)<=0)  // 确保扰动会变量仍为负值
			{
				changeBit = rd.nextInt(randomUpBoundary);
				bitValue= arrayC[changeBit];
				deta = Math.pow(2,leftSideLen-1-changeBit);
			}
		}
		else if(unPositiveSet.contains(in))// 扰动变量满足非正约束
		{
			changeBit = rd.nextInt(randomUpBoundary);
			 
			while(changeBit == 0 )  // 确保扰动会变量仍非正
			{
				changeBit = rd.nextInt(randomUpBoundary);
			}
		} 
		else    // unZeroSet.contains((new Integer(changeVari)) 即扰动变量满足非0约束
		{
			changeBit = rd.nextInt(randomUpBoundary);
			 
			bitValue= arrayC[changeBit];
			deta = Math.pow(2,leftSideLen-1-changeBit);
			
			if(changeBit !=0)
			{
				while(Double.compare(0, (1-2*firstBitValue)*(1-2*bitValue)*deta+value) == 0)   // 当变量扰动后值为0
				{
					changeBit = rd.nextInt(randomUpBoundary);
					bitValue= arrayC[changeBit];
					deta = Math.pow(2,leftSideLen-1-changeBit);
				}
			}
		}
		
		/**
		 *  扰动
		 */
		deta = Math.pow(2,leftSideLen-1-changeBit);   // 变化量	
		bitValue = arrayC[changeBit];
		Double v1 = new Double(value+deta);
		Double v2 = new Double(value-deta);
		Double v3 = new Double(-value);
		
		arrayC[changeBit] = 1-bitValue;
		if(changeBit != 0)
    	 {
    		 if(bitValue == 0 && firstBitValue==0)
	    	 {
		    	 listC.set(indexC,v1);
	    	 }
	    	 else if(bitValue ==0 && firstBitValue==1)
	    	 {
	    		 listC.set(indexC,v2);
	    	 }
	    	 else if(bitValue ==1 && firstBitValue==0)
	    	 {
	    		 listC.set(indexC,v2);
	    	 }
	    	 else
	    	 {
	    		 listC.set(indexC,v1);
	    	 }
    	 }
    	 else // changeBit == 0,此时deta没有意义
    	 {
    		 listC.set(indexC,v3);
    	 }
	}	
	
	
	/**
	 * 更新配置为最近的临时配置(针对整型行参）
	 */
	private static void updateConfiguration()
	{
		
		int bitValue;  // 位值，0或1
		if(changeVari <= inputCount)
		{
			bitValue = inputBits.get(changeVari-1)[changeBit];
			
			// 更新inputBits
			inputBits.get(changeVari-1)[changeBit] = 1-bitValue;
			
			// 更新inputValue
			inputValue.set(changeVari-1,tempInputValue.get(changeVari-1));
		}
		else
		{
			bitValue = auxilaryBits.get(changeVari-1-inputCount)[changeBit];
			
			// 更新auxilaryBits
			auxilaryBits.get(changeVari-1-inputCount)[changeBit] = 1-bitValue;
			
			// 更新auxilaryValue
			auxilaryValue.set(changeVari-1-inputCount, tempAuxilaryValue.get(changeVari-1-inputCount));
		}
	}
	
	
	/**
	 * 更新配置(针对浮点型或混合型行参）
	 */
	private static void updateConfiguration2()
	{
		int bitValue;  // 位值，0或1
		if(changeVari <= inputCount)
		{
			bitValue = inputBits2.get(changeVari-1)[changeBit];
			
			// 更新inputBits
			inputBits2.get(changeVari-1)[changeBit] = 1-bitValue;
			
			// 更新inputValue
			inputValue2.set(changeVari-1, tempInputValue2.get(changeVari-1));
		}
		else
		{
			bitValue = auxilaryBits2.get(changeVari-1-inputCount)[changeBit];
			
			// 更新auxilaryBits
			auxilaryBits2.get(changeVari-1-inputCount)[changeBit] = 1-bitValue;
			
			// 更新auxilaryValue
			auxilaryValue2.set(changeVari-1-inputCount, tempAuxilaryValue2.get(changeVari-1-inputCount));
		}
	}
	
	
	
	
	/**
	 * 更新最小能源函数值对应的参数配置(针对整型行参）
	 */
	private static void updateMiniConfiguration()
	{
		mInputValue.clear();
		mInputValue.addAll(tempInputValue);
		mAuxilaryValue.clear();
		mAuxilaryValue.addAll(tempAuxilaryValue);
	}
	
	
	/**
	 * 更新最小能源函数值对应的参数配置(针对浮点型或混合型行参）
	 */
	private static void updateMiniConfiguration2()
	{
		mInputValue2.clear();
		mInputValue2.addAll(tempInputValue2);
		mAuxilaryValue2.clear();
		mAuxilaryValue2.addAll(tempAuxilaryValue2);
	}
	
	/**
	 *  更新路径节点能源函数值
	 */
	private static void updateNodeEnergyValueSetInPath()
	{
		nodeEnergyValueSetInPath.clear();
		nodeEnergyValueSetInPath.addAll(tempNodeEnergyValueSetInPath);
	}
	
	
	/**
	 * 确定初始温度
	 */
	private static double determineT0(){ 
		/** 初始温度的值根据函数变化而变化，必须满足  T0 >= max{deta(energyValue)}/(-ln0.9)   
		   推导过程如下：  记 energyValue 为 E
		      e^(-deta(E)/T0) >= 0.9
		          -deta(E)/T0 >= ln0.9
		              deta(E)/T0 <= ln0.9
		                  T0 >= deta(E)/(-ln0.9)
		                    T0 >= max{deta(E)}/(-ln0.9)
		                    */ 
		
		// for isLeapYear
//		return -(4*Math.pow(2, len)-1)/Math.log(0.9);
		// for triangle
//		return -Math.pow(2, 4*len)/Math.log(0.9); 
		// for expint
//		return -4*Math.pow(2, leftSideLength)/Math.log(0.9);
		// for bessj
//		return -4*(1<<leftSideLength)/Math.log(0.9);
		// for julday
//		return -40000*Math.pow(2, length)/Math.log(0.9);
		// for plgndr
//		return -10*Math.pow(2, leftSideLength)/Math.log(0.9);
		// for ei
//		return -40*Math.pow(2, leftSideLength)/Math.log(0.9);
		// for caldat
//		return -40*Math.pow(2, leftSideLength)/Math.log(0.9);
		// for icrc
		return -4*Math.pow(2, leftSideLength)/Math.log(0.9);
	}
	
	
	/**
	 * 确定冰点温度
	 */
	private static double determineTf(){ 
		/** 冰点温度的值根据函数变化而变化，必须满足  Tf <= min{deta(energyValue)}/(30ln2)   
		    推导过程如下： 记energyValue 为 E
		      e^(-deta(E)/Tf) <= 2^(-30)
		          -deta(E)/Tf <= -30ln2
		               deta(E)/Tf >= 30ln2
		                    Tf <= deta(E)/(30ln2)
		                         Tf <= min{deta(E)}/(30ln2)
		                         */
		    
		// for isLeapYear
//		return 1/(30*Math.log(2));
		// for triangle
//		return 1/(30*Math.log(2));
		 // for expint
//		return Math.pow(2, -rightSideLength)/(30*Math.log(2));
		// for bessj
//		if(rightSideLength == 1020)
//		{
//			return Math.pow(2, -64)/(30*Math.log(2));
//		}
//		else
//		{
//			return Math.pow(2, -rightSideLength)/(30*Math.log(2));
//		}
		
		//for julday
//		return 1/(30*Math.log(2));
		// for plgndr
//		return Math.pow(2, -rightSideLength)/(30*Math.log(2));
		// for ei
//		return Math.pow(2, -rightSideLength)/(30*Math.log(2));
		// for caldat
//		return 1/(30*Math.log(2));
		// for icrc
		return 1/(30*Math.log(2));
		
		
	}
	
	
	/**
	 * 确定是否接受扰动（针对整型行参）
	 * @return
	 */
	private static boolean acceptPerturbation()
	{ 
		if(tempEnergyValue <= energyValue)
		{
			return true;
		}
		else
		{
			if(Math.random()<Math.exp((energyValue-tempEnergyValue)/t))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	
	
	/**
	 * 确定是否接受扰动（针对负点型或混合型行参）
	 * @return
	 */
	private static boolean acceptPerturbation2()
	{ 
		if(Double.isNaN(energyValue2) || Double.isInfinite(energyValue2)) return true;
		if(Double.isInfinite(tempEnergyValue2) || Double.isNaN(tempEnergyValue2)) return false;
		if(tempEnergyValue2 <= energyValue2)
		{
			return true;
		}
		else
		{
			if(Double.compare(Math.random(),Math.exp((energyValue2-tempEnergyValue2)/t))<0)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	
	
	/**
	 * 执行函数
	 */
	private static void callFunction()
	{
		//开始计时
			Builder.function_time = Builder.function_time - System.currentTimeMillis();
			
//				Builder.callCPP.callCheckX(Builder.parameters[0]);
//				Builder.callCPP.callTriangle(mInputValue.get(0).intValue(), mInputValue.get(1).intValue(), mInputValue.get(2).intValue());
//			   Builder.callCPP.callIsLeapYear(mInputValue.get(0).intValue());
//				public native boolean callIsValidDate(int day, int month, int year);
//				Builder.callCPP.callIsLeapYear((int)Builder.parameters[Builder.generatingParameterIndex]);
//				Builder.callCPP.callGetRootOfQuadraticF((float)Builder.parameters[0], (float)Builder.parameters[1], (float)Builder.parameters[2]);
//			    Builder.callCPP.callExpint(mInputValue2.get(0).intValue(), mInputValue2.get(1).doubleValue());
//			    Builder.callCPP.callBessj(mInputValue2.get(0).intValue(), mInputValue2.get(1).doubleValue());
//			    Builder.callCPP.callJulday(mInputValue.get(0).intValue(), mInputValue.get(1).intValue(), mInputValue.get(2).intValue());
//			    Builder.callCPP.callPlgndr(mInputValue2.get(0).intValue(), mInputValue2.get(1).intValue(), mInputValue2.get(2).doubleValue());
//			    Builder.callCPP.callEi(mInputValue2.get(0).doubleValue());
//			    Builder.callCPP.callCaldat(mInputValue.get(0).intValue(), mInputValue.get(1).intValue(), mInputValue.get(2).intValue(), mInputValue.get(3).intValue());
			    Builder.callCPP.callIcrc(mInputValue.get(0).shortValue(), mInputValue.get(1).longValue(), mInputValue.get(2).shortValue(), mInputValue.get(3).intValue());

			
			//结束计时
			Builder.function_time = Builder.function_time + System.currentTimeMillis();
			//记录目标程序被执行一次
			Builder.function_frequency++;
	}
	
	private static boolean isInArray(int number,int[] nodeSet)
	{
		boolean flag = false;
		for(int i=0,size=nodeSet.length;i<size;i++)
		{
			if(nodeSet[i]==number)
			{
				flag  = true;
				break;
			}
		}
		return flag;
	}
	
	/**
	 * 从文件读取 函数运行时经过的节点名集合 
	 */
	private static List<String> readPathFromFile(String filePath)
	{
		List<String> cycleList = new ArrayList<String>();
		/**
		 *  for bessj
		 */
//		cycleList.add("node9");
//		cycleList.add("node13");
		
		/**
		 * for expint
		 */
//		cycleList.add("node10");
//		cycleList.add("node21");
//		cycleList.add("node16");

		/**
		 *  for ei
		 */
//		cycleList.add("node8");
//		cycleList.add("node16");
		
		/**
		 * for icrc
		 */
		cycleList.add("node4");
		cycleList.add("node10");
		
		List<String> nodeNameList = new ArrayList<String>();
		try{
			String str;
			BufferedReader in = new BufferedReader(new FileReader(filePath));
			String temp=new String();
			
			while((str = in.readLine())!=null)
			{
				if(!str.equals(""))
				{
					String[] array = str.split(" ");
					nodeNameList.add(array[0]);
					temp = array[0];
					break;
				}
			}
			
			while((str = in.readLine())!=null)
			{
				if (!str.equals(""))
				{
					String[] array = str.split(" ");
					if(temp.equals(array[0])) continue;  // 排除连续的节点
					nodeNameList.add(array[0]);
					temp = null;
					temp = array[0];
				}
			}
			in.close();
		}
		catch(Exception e){
			System.out.print(e.toString());
		}
		
		/* 将循环中重复部分删除   */
		for(int i=0,size=cycleList.size();i<size;i++)
		{
			String cycleNode = cycleList.get(i);
			if(!nodeNameList.contains(cycleNode))continue;
			int firstindex = nodeNameList.indexOf(cycleNode);
			int lastindex = nodeNameList.lastIndexOf(cycleNode);
			if(firstindex == lastindex) continue;
			List<String> l = nodeNameList.subList(firstindex+1, lastindex);
			if(l.indexOf(cycleNode) == -1)continue;
			int secondeindex = l.indexOf(cycleNode)+firstindex+1;
			l=null;
			List<String> part1 = nodeNameList.subList(0, secondeindex);
			List<String> part2 = nodeNameList.subList(lastindex, nodeNameList.size());
			part1.addAll(part2);
			nodeNameList = null;
			nodeNameList = part1;
			part2 = null;
		}
		return nodeNameList;
	}
	
	/**
	 *  判断节点名集合是否对应目标路径
	 */
	private static boolean isTargetPath(CFGPath targetPath,List<String> snoNameList)
	{
		List<SimpleCFGNode> snoList = targetPath.getPath();
		List<String> tSnoNameList = new ArrayList<String>();
		for(int i=0;i<snoList.size();i++)
		{
			tSnoNameList.add(snoList.get(i).getName());
		}
		if(tSnoNameList.containsAll(snoNameList) && snoNameList.containsAll(tSnoNameList))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	/**
	 *  获得路径中当前节点的前一个节点名
	 * @param path
	 * @param currentNodeName
	 * @return
	 */
	private static String getPreNodeName(CFGPath path,SimpleCFGNode currentNode)  // 注意，可能不适用于循环    by OJS
	{
		List<SimpleCFGNode> snoList = path.getPath();
		
		if(!snoList.contains(currentNode) || snoList.get(0).equals(currentNode))
		{
			return null;
		}
		else
		{
			return snoList.get(snoList.indexOf(currentNode)-1).getName();
		}
	}
	
	/**
	 *  获得路径中最后一个该名称的节点的前一个节点名
	 * @param path
	 * @param currentNodeName
	 * @return
	 */
	private static String getLastPreNodeName(CFGPath path,String currentNodeName)  // 注意，可能不适用于循环    by OJS
	{
		
		List<SimpleCFGNode> snoList = path.getPath();
		List<String> snoNameList = new ArrayList<String>();
		for(int i=0,size=snoList.size();i<size;i++)
		{
			snoNameList.add(snoList.get(i).getName());
		}
		if(!snoNameList.contains(currentNodeName) || snoNameList.get(0).equals(currentNodeName))
		{
			return null;
		}
		else
		{
			return snoNameList.get(snoNameList.lastIndexOf(currentNodeName)-1);
		}
	}
	
	
	/**
	 *  判断节点是否在路径中
	 * @param nodeName
	 * @param path
	 * @return
	 */
	private static boolean isNodeInPath(String nodeName,CFGPath path)
	{
		List<SimpleCFGNode> sno = path.getPath();
		List<String> snoNameList = new ArrayList<String>();
		for(int i=0,size=sno.size();i<size;i++)
		{
			snoNameList.add(sno.get(i).getName());
		}
		if(snoNameList.contains(nodeName))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	/**
	 *  初始化路径节点信息（节点名，节点能源函数值）,针对整形行参
	 * @param path
	 */
	private static void initialNodeInforInPath(CFGPath path)
	{
		if(nodeSetInPath == null )
		{
			nodeSetInPath = new ArrayList<String>();
		}
		else nodeSetInPath.clear();
		
		if(nodeEnergyValueSetInPath == null)
		{
			nodeEnergyValueSetInPath = new ArrayList<Double>();
		}
		else nodeEnergyValueSetInPath.clear();
		
		List<SimpleCFGNode> snoList = path.getPath();
		
		/* 置已完成能源函数值计算的节点集为空    */
		if(finishCalNodeSet == null)
		{
			finishCalNodeSet = new ArrayList<String>();  
		}
		else finishCalNodeSet.clear();
		
		for(int i=0,size=snoList.size();i<size;i++)
		{
			SimpleCFGNode node = snoList.get(i);
			String nodename = node.getName();
			nodeSetInPath.add(nodename);
			nodeEnergyValueSetInPath.add(new Double(calNodeEnergyValue(node)));
			finishCalNodeSet.add(nodename);  // 添加完成计算的节点名称
		}
	}
	
	/**
	 *  初始化路径节点信息（节点名，节点能源函数值），针对浮点、混合行参
	 * @param path
	 */
	private static void initialNodeInforInPath2(CFGPath path)
	{
		if(nodeSetInPath != null )
		{
			nodeSetInPath.clear();
		}
		else nodeSetInPath = new ArrayList<String>();
		
		if(nodeEnergyValueSetInPath != null)
		{
			nodeEnergyValueSetInPath.clear();
		}
		else nodeEnergyValueSetInPath = new ArrayList<Double>();
		
		List<SimpleCFGNode> snoList = path.getPath();
		
		/* 置已完成能源函数值计算的节点集为空    */
		if(finishCalNodeSet == null)
		{
			finishCalNodeSet = new ArrayList<String>();  
		}
		else finishCalNodeSet.clear();
		
		for(int i=0,size=snoList.size();i<size;i++)
		{
			SimpleCFGNode node = snoList.get(i);
			String nodeName = node.getName();
			nodeSetInPath.add(nodeName);
			nodeEnergyValueSetInPath.add(new Double(calNodeEnergyValue2(node)));
			finishCalNodeSet.add(nodeName);  // 添加完成计算的节点名称
		}
	}
	
	/**
	 *  初始化整型变量集
	 */
	private static void initialIntSet()
	{
		intSet = new TreeSet<Integer>();
		
		/**
		 *  for expint
		 */
//		intSet.add(new Integer(1));
//		intSet.add(new Integer(2+1));
//		intSet.add(new Integer(2+3));
//		intSet.add(new Integer(2+6));
//		intSet.add(new Integer(2+7));
//		intSet.add(new Integer(2+8));
//		intSet.add(new Integer(2+13));
//		intSet.add(new Integer(2+14));
//		intSet.add(new Integer(2+18));
//		
		/**
		 *  for bessj
		 */
//		intSet.add(new Integer(1));
//		intSet.add(new Integer(2+1));
//		intSet.add(new Integer(2+2));
//		intSet.add(new Integer(2+7));
//		intSet.add(new Integer(2+8));
//		intSet.add(new Integer(2+9));
//		intSet.add(new Integer(2+10));
//		intSet.add(new Integer(2+11));
//		intSet.add(new Integer(2+12));
//		intSet.add(new Integer(2+13));
//		intSet.add(new Integer(2+14));
//		intSet.add(new Integer(2+15));
		
		/**
		 *  for plgndr
		 */
//		intSet.add(new Integer(1));
//		intSet.add(new Integer(2));
//		intSet.add(new Integer(3+1));
//		intSet.add(new Integer(3+2));
//		intSet.add(new Integer(3+4));
//		intSet.add(new Integer(3+5));
//		intSet.add(new Integer(3+7));
//		intSet.add(new Integer(3+8));
//		intSet.add(new Integer(3+9));
//		intSet.add(new Integer(3+10));
//		intSet.add(new Integer(3+11));
//		intSet.add(new Integer(3+12));
//		intSet.add(new Integer(3+13));
//		intSet.add(new Integer(3+14));
		
		
		
	}
	
	/**
	 *  初始化限制集合
	 */
	private static void initialConstraintSet()
	{
		positiveSet = new TreeSet<Integer>();
		negativeSet = new TreeSet<Integer>();
		unPositiveSet =new TreeSet<Integer>();
		unNegativeSet = new TreeSet<Integer>();
		unZeroSet = new TreeSet<Integer>();
		
		/** 
		 * for isLearYear
		 */
//		positiveSet.add(new Integer(1));
//		positiveSet.add(new Integer(2));
//		positiveSet.add(new Integer(3));
//		positiveSet.add(new Integer(4));
		
		/**
		 *  for triangle
		 */
//		positiveSet.add(new Integer(3+1));
//		positiveSet.add(new Integer(3+2));
//		positiveSet.add(new Integer(3+3));
//		positiveSet.add(new Integer(3+4));
//		positiveSet.add(new Integer(3+5));
//		positiveSet.add(new Integer(3+6));
//		unZeroSet.add(new Integer(3+7));
//		unZeroSet.add(new Integer(3+8));
//		unZeroSet.add(new Integer(3+9));
//		unZeroSet.add(new Integer(3+10));
//		unZeroSet.add(new Integer(3+11));
//		unPositiveSet.add(new Integer(3+12));	
//		unPositiveSet.add(new Integer(3+13));
//		unPositiveSet.add(new Integer(3+14));
//		unPositiveSet.add(new Integer(3+15));
//		unPositiveSet.add(new Integer(3+16));
//		unPositiveSet.add(new Integer(3+17));
		
		/**
		 *  for expint 
		 */
//		positiveSet.add(new Integer(2+10));
//		positiveSet.add(new Integer(2+17));
//		unPositiveSet.add(new Integer(2+11));
//		unPositiveSet.add(new Integer(2+12));
//		unNegativeSet.add(new Integer(2+3));
//		unNegativeSet.add(new Integer(2+4));
//		unNegativeSet.add(new Integer(2+14));
//		unNegativeSet.add(new Integer(2+19));
//		unNegativeSet.add(new Integer(2+20));
//		negativeSet.add(new Integer(2+1));
//		negativeSet.add(new Integer(2+2));
//		negativeSet.add(new Integer(2+15));
//		negativeSet.add(new Integer(2+16));
//		negativeSet.add(new Integer(2+18));
//		unZeroSet.add(new Integer(2+5));
//		unZeroSet.add(new Integer(2+6));
//		unZeroSet.add(new Integer(2+7));
//		unZeroSet.add(new Integer(2+8));
//		unZeroSet.add(new Integer(2+9));
//		unZeroSet.add(new Integer(2+13));
		
		/**
		 *  for bessj
		 */
//		positiveSet.add(new Integer(2+4));
//		positiveSet.add(new Integer(2+5));
//		positiveSet.add(new Integer(2+7));
//		positiveSet.add(new Integer(2+15));
////		unPositiveSet.add(new Integer(2+3));
//		negativeSet.add(new Integer(2+3));
//		unPositiveSet.add(new Integer(2+6));
//		unPositiveSet.add(new Integer(2+9));
//		unPositiveSet.add(new Integer(2+14));
//		negativeSet.add(new Integer(2+1));
//		negativeSet.add(new Integer(2+10));
//		negativeSet.add(new Integer(2+12));
//		unNegativeSet.add(new Integer(2+2));
//		unNegativeSet.add(new Integer(2+11));
//		unNegativeSet.add(new Integer(2+13));
//		unZeroSet.add(new Integer(2+8));
		
		/**
		 *  for julday
		 */
//		positiveSet.add(new Integer(3+4));
//		unPositiveSet.add(new Integer(3+5));
//		negativeSet.add(new Integer(3+3));
//		negativeSet.add(new Integer(3+7));
//		unNegativeSet.add(new Integer(3+2));
//		unNegativeSet.add(new Integer(3+6));
//		unZeroSet.add(new Integer(3+1));
		
		/**
		 * for plgndr
		 */
//		positiveSet.add(new Integer(3+2));
//		positiveSet.add(new Integer(3+3));
//		positiveSet.add(new Integer(3+7));
//		positiveSet.add(new Integer(3+14));
//		unPositiveSet.add(new Integer(3+5));
//		unPositiveSet.add(new Integer(3+6));
//		unPositiveSet.add(new Integer(3+8));
//		unPositiveSet.add(new Integer(3+13));
//		negativeSet.add(new Integer(3+1));
//		negativeSet.add(new Integer(3+10));
//		unNegativeSet.add(new Integer(3+4));
//		unNegativeSet.add(new Integer(3+9));
//		unZeroSet.add(new Integer(3+11));
//		unZeroSet.add(new Integer(3+12));
		
		/**
		 *  for ei
		 */
//		positiveSet.add(new Integer(1+2));
//		positiveSet.add(new Integer(1+5));
//		unPositiveSet.add(new Integer(1+1));
//		unPositiveSet.add(new Integer(1+4));
//		negativeSet.add(new Integer(1+3));
//		negativeSet.add(new Integer(1+6));
//		negativeSet.add(new Integer(1+8));
//		negativeSet.add(new Integer(1+10));
//		unNegativeSet.add(new Integer(1+7));
//		unNegativeSet.add(new Integer(1+9));
//		unNegativeSet.add(new Integer(1+11));
//		unNegativeSet.add(new Integer(1+12));
		
		/**
		 *  for caldat
		 */
//		positiveSet.add(new Integer(4+5));
//		positiveSet.add(new Integer(4+7));
//		positiveSet.add(new Integer(4+10));
//		unPositiveSet.add(new Integer(4+6));
//		unPositiveSet.add(new Integer(4+8));
//		unPositiveSet.add(new Integer(4+9));
//		negativeSet.add(new Integer(4+2));
//		negativeSet.add(new Integer(4+3));
//		negativeSet.add(new Integer(4+11));
//		unNegativeSet.add(new Integer(4+1));
//		unNegativeSet.add(new Integer(4+4));
//		unNegativeSet.add(new Integer(4+12));
		
		/**
		 * for Icrc
		 */
		positiveSet.add(new Integer(4+5));
		unPositiveSet.add(new Integer(4+6));
		negativeSet.add(new Integer(4+2));
		negativeSet.add(new Integer(4+3));
		negativeSet.add(new Integer(4+7));
		negativeSet.add(new Integer(4+10));
		unNegativeSet.add(new Integer(4+1));
		unNegativeSet.add(new Integer(4+4));
		unNegativeSet.add(new Integer(4+8));
		unNegativeSet.add(new Integer(4+9));
		
	}
	
	/**
	 * 初始化扰动变量范围集合
	 * @param path
	 */
	private static void initialPerturRangeSet(CFGPath path)
	{
		perturRangeSet = new TreeSet<Integer>();
		List<SimpleCFGNode> snoList = path.getPath();
		List<String> nameList = new ArrayList<String>();
		for(int i=0,size=snoList.size();i<size;i++)
		{
			nameList.add(snoList.get(i).getName());
		}
		
		/**
		 * for isLeapYear
		 */
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		perturRangeSet.add(new Integer(3));
//		perturRangeSet.add(new Integer(4));
		/**
		 *  for triangle
		 */
//		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		perturRangeSet.add(new Integer(3));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(3+1));
//			perturRangeSet.add(new Integer(3+2));
//			perturRangeSet.add(new Integer(3+3));
//		}
//		if(nameList.contains("node4"))
//		{
//			perturRangeSet.add(new Integer(3+4));
//			perturRangeSet.add(new Integer(3+5));
//			perturRangeSet.add(new Integer(3+6));
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(3+7));
//			perturRangeSet.add(new Integer(3+8));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(3+9));
//			perturRangeSet.add(new Integer(3+10));
//			perturRangeSet.add(new Integer(3+11));
//		}
//		if(nameList.contains("node9"))
//		{
//			if(nameList.get(nameList.indexOf("node9")-1).equals("node2"))
//			{
//				perturRangeSet.add(new Integer(3+15));
//				perturRangeSet.add(new Integer(3+16));
//				perturRangeSet.add(new Integer(3+17));
//			}
//			else if(nameList.get(nameList.indexOf("node9")-1).equals("node3"))
//			{
//				perturRangeSet.add(new Integer(3+12));
//				perturRangeSet.add(new Integer(3+13));
//				perturRangeSet.add(new Integer(3+14));
//			}
//			else;
//		}
		
		/**
		 *  for expint
		 */
//		 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(2+1));
//			perturRangeSet.add(new Integer(2+2));
//		}
//		if(nameList.contains("node4"))
//		{
//			perturRangeSet.add(new Integer(2+3));
//			perturRangeSet.add(new Integer(2+4));
//			perturRangeSet.add(new Integer(2+5));
//			perturRangeSet.add(new Integer(2+6));
//			perturRangeSet.add(new Integer(2+7));
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(2+8));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(2+9));
//		}
//		if(nameList.contains("node9"))
//		{
//			perturRangeSet.add(new Integer(2+10));
//		}
//		if(nameList.contains("node10"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node10")-1).equals("node12"))
//			{
//				perturRangeSet.add(new Integer(2+17));
//			}
//		}
//		if(nameList.contains("node13"))
//		{
//			perturRangeSet.add(new Integer(2+11));
//		}
//		if(nameList.contains("node15"))
//		{
//			perturRangeSet.add(new Integer(2+12));
//		}
//		if(nameList.contains("node16"))
//		{
//			if(getLastPreNodeName(path,"node16").equals("node25")&&isNodeInPath("node19",path))
//			{
//				perturRangeSet.add(new Integer(2+19));
//			}
//			else if(getLastPreNodeName(path,"node16").equals("node25")&&isNodeInPath("node20",path))
//			{
//				perturRangeSet.add(new Integer(2+20));
//			}
//		}
//		if(nameList.contains("node19"))
//		{
//			perturRangeSet.add(new Integer(2+13));
//		}
//		if(nameList.contains("node22"))
//		{
//			perturRangeSet.add(new Integer(2+14));
//		}
//		if(nameList.contains("node23"))
//		{
//			perturRangeSet.add(new Integer(2+18));
//		}
//		if(nameList.contains("node26"))
//		{
//			if(isNodeInPath("node19",path))
//			{
//				perturRangeSet.add(new Integer(2+15));
//			}
//			else
//			{
//				perturRangeSet.add(new Integer(2+16));
//			}
//		}
		
		/**
		 *  for bessj
		 */
		
		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(2+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			if(!nameList.contains("node3"))
//			{
//				perturRangeSet.add(new Integer(2+2));
//			}
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(2+3));
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(2+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(2+5));
//		}
//		if(nameList.contains("node10"))
//		{
//			perturRangeSet.add(new Integer(2+10));
//		}
//		if(nameList.contains("node11"))
//		{
//			if(!nameList.contains("node10"))
//			perturRangeSet.add(new Integer(2+11));
//		}
//		if(nameList.contains("node12"))
//		{
//			perturRangeSet.add(new Integer(2+6));
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(2+15));
//		}
//		if(nameList.contains("node16"))
//		{
//			perturRangeSet.add(new Integer(2+7));
//		}
//		if(nameList.contains("node17"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node17")-1).equals("node15"))
//			{
//				perturRangeSet.add(new Integer(2+9));
//			}
//		}
//		if(nameList.contains("node13"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node13")-1).equals("node20"))
//			{
//				perturRangeSet.add(new Integer(2+8));
//			}
//		}
//		if(nameList.contains("node22"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node22")-2).equals("node12"))
//			{
//				perturRangeSet.add(new Integer(2+14));
//			}
//		}
		
		/**
		 *  for julday
		 */
		
//		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		perturRangeSet.add(new Integer(3));
//		
//		// 添加辅助变量
//		if(nameList.contains("node4"))
//		{
//			if(nameList.get(nameList.indexOf("node4")-1).equals("node2"))
//			{
//				perturRangeSet.add(new Integer(3+1));
//			}
//		}
//		if(nameList.contains("node5"))
//		{
//			perturRangeSet.add(new Integer(3+3));
//		}
//		if(nameList.contains("node6"))
//		{
//			if(nameList.get(nameList.indexOf("node6")-1).equals("node4"))
//			{
//				perturRangeSet.add(new Integer(3+2));
//			}
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(3+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(3+5));
//		}
//		if(nameList.contains("node11"))
//		{
//			perturRangeSet.add(new Integer(3+6));
//		}
//		if(nameList.contains("node12"))
//		{
//			if(nameList.get(nameList.indexOf("node12")-1).equals("node10"))
//			{
//				perturRangeSet.add(new Integer(3+7));
//			}
//		}
		
		/**
		 *  for plgndr
		 */
		
//		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		perturRangeSet.add(new Integer(3));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(3+1));
//			perturRangeSet.add(new Integer(3+2));
//			perturRangeSet.add(new Integer(3+3));
//		}
//		if(nameList.contains("node4"))
//		{
//			if(nameList.get(nameList.indexOf("node4")-1).equals("node2"))
//			{
//				perturRangeSet.add(new Integer(3+4));
//				perturRangeSet.add(new Integer(3+5));
//				perturRangeSet.add(new Integer(3+6));
//			}
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(3+7));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(3+9));
//		}
//		if(nameList.contains("node9"))
//		{
//			if(nameList.get(nameList.indexOf("node9")-1).equals("node5"))
//			{
//				perturRangeSet.add(new Integer(3+8));
//			}
//			else if(nameList.get(nameList.indexOf("node9")-1).equals("node7") && !nameList.contains("node8"))
//			{
//				perturRangeSet.add(new Integer(3+10));
//			}
//		}
//		if(nameList.contains("node11"))
//		{
//			perturRangeSet.add(new Integer(3+11));
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(3+12));
//		}
//		if(nameList.contains("node15"))
//		{
//			perturRangeSet.add(new Integer(3+13));
//		}
//		if(nameList.contains("node16"))
//		{perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(2+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			if(!nameList.contains("node3"))
//			{
//				perturRangeSet.add(new Integer(2+2));
//			}
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(2+3));
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(2+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(2+5));
//		}
//		if(nameList.contains("node10"))
//		{
//			perturRangeSet.add(new Integer(2+10));
//		}
//		if(nameList.contains("node11"))
//		{
//			if(!nameList.contains("node10"))
//			perturRangeSet.add(new Integer(2+11));
//		}
//		if(nameList.contains("node12"))
//		{
//			perturRangeSet.add(new Integer(2+6));
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(2+15));
//		}
//		if(nameList.contains("node16"))
//		{
//			perturRangeSet.add(new Integer(2+7));
//		}
//		if(nameList.contains("node17"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node17")-1).equals("node15"))
//			{
//				perturRangeSet.add(new Integer(2+9));
//			}
//		}
//		if(nameList.contains("node13"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node13")-1).equals("node20"))
//			{
//				perturRangeSet.add(new Integer(2+8));
//			}
//		}
//		if(nameList.contains("node22"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node22")-2).equals("node12"))
//			{
//				perturRangeSet.add(new Integer(2+14));
//			}
//		}
//			if(!nameList.contains("node15"))
//			{
//				perturRangeSet.add(new Integer(3+14));
//			}
//			
//		}
		
		/**
		 *  for ei
		 */
		
		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		
//		//添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(1+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			perturRangeSet.add(new Integer(1+2));
//		}
//		if(nameList.contains("node5"))
//		{
//			perturRangeSet.add(new Integer(1+3));
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(1+12));
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(1+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node8")-1).equals("node10"))
//			{
//				perturRangeSet.add(new Integer(1+7));
//			}
//		}
//		if(nameList.contains("node11"))
//		{
//			perturRangeSet.add(new Integer(1+6));
//		}
//		if(nameList.contains("node15"))
//		{
//			perturRangeSet.add(new Integer(1+5));
//		}
//		if(nameList.contains("node19"))
//		{
//			perturRangeSet.add(new Integer(1+8));
//		}
//		if(nameList.contains("node20"))
//		{
//			perturRangeSet.add(new Integer(1+9));
//		}
//		if(nameList.contains("node21"))
//		{
//			perturRangeSet.add(new Integer(1+10));
//		}
//		if(nameList.contains("node22"))
//		{
//			perturRangeSet.add(new Integer(1+11));
//		}
		
		/**
		 * for caldat 
		 */
		// 添加输入变量
//		perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		perturRangeSet.add(new Integer(3));
//		perturRangeSet.add(new Integer(4));
//		
//		//添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(4+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			perturRangeSet.add(new Integer(4+2));
//		}
//		if(nameList.contains("node5"))
//		{
//			perturRangeSet.add(new Integer(4+3));
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(4+4));
//		}
//		if(nameList.contains("node9"))
//		{
//			perturRangeSet.add(new Integer(4+5));
//		}
//		if(nameList.contains("node10"))
//		{
//			if(!nameList.contains("node9"))
//			{
//				perturRangeSet.add(new Integer(4+6));
//			}
//		}
//		if(nameList.contains("node12"))
//		{
//			pperturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(2+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			if(!nameList.contains("node3"))
//			{
//				perturRangeSet.add(new Integer(2+2));
//			}
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(2+3));
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(2+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(2+5));
//		}
//		if(nameList.contains("node10"))
//		{
//			perturRangeSet.add(new Integer(2+10));
//		}
//		if(nameList.contains("node11"))
//		{
//			if(!nameList.contains("node10"))
//			perturRangeSet.add(new Integer(2+11));
//		}
//		if(nameList.contains("node12"))
//		{
//			perturRangeSet.add(new Integer(2+6));
//		}perturRangeSet.add(new Integer(1));
//		perturRangeSet.add(new Integer(2));
//		
//		// 添加辅助变量
//		if(nameList.contains("node3"))
//		{
//			perturRangeSet.add(new Integer(2+1));
//		}
//		if(nameList.contains("node4"))
//		{
//			if(!nameList.contains("node3"))
//			{
//				perturRangeSet.add(new Integer(2+2));
//			}
//		}
//		if(nameList.contains("node6"))
//		{
//			perturRangeSet.add(new Integer(2+3));
//		}
//		if(nameList.contains("node7"))
//		{
//			perturRangeSet.add(new Integer(2+4));
//		}
//		if(nameList.contains("node8"))
//		{
//			perturRangeSet.add(new Integer(2+5));
//		}
//		if(nameList.contains("node10"))
//		{
//			perturRangeSet.add(new Integer(2+10));
//		}
//		if(nameList.contains("node11"))
//		{
//			if(!nameList.contains("node10"))
//			perturRangeSet.add(new Integer(2+11));
//		}
//		if(nameList.contains("node12"))
//		{
//			perturRangeSet.add(new Integer(2+6));
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(2+15));
//		}
//		if(nameList.contains("node16"))
//		{
//			perturRangeSet.add(new Integer(2+7));
//		}
//		if(nameList.contains("node17"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node17")-1).equals("node15"))
//			{
//				perturRangeSet.add(new Integer(2+9));
//			}
//		}
//		if(nameList.contains("node13"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node13")-1).equals("node20"))
//			{
//				perturRangeSet.add(new Integer(2+8));
//			}
//		}
//		if(nameList.contains("node22"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node22")-2).equals("node12"))
//			{
//				perturRangeSet.add(new Integer(2+14));
//			}
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(2+15));
//		}
//		if(nameList.contains("node16"))
//		{
//			perturRangeSet.add(new Integer(2+7));
//		}
//		if(nameList.contains("node17"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node17")-1).equals("node15"))
//			{
//				perturRangeSet.add(new Integer(2+9));
//			}
//		}
//		if(nameList.contains("node13"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node13")-1).equals("node20"))
//			{
//				perturRangeSet.add(new Integer(2+8));
//			}
//		}
//		if(nameList.contains("node22"))
//		{
//			if(nameList.get(nameList.lastIndexOf("node22")-2).equals("node12"))
//			{
//				perturRangeSet.add(new Integer(2+14));
//			}
//		}erturRangeSet.add(new Integer(4+7));
//		}
//		if(nameList.contains("node13"))
//		{
//			if(!nameList.contains("node12"))
//			{
//				perturRangeSet.add(new Integer(4+8));
//			}
//		}
//		if(nameList.contains("node14"))
//		{
//			perturRangeSet.add(new Integer(4+9));
//		}
//		if(nameList.contains("node15"))
//		{
//			if(!nameList.contains("node14"))
//			{
//				perturRangeSet.add(new Integer(4+10));
//			}
//		}
//		if(nameList.contains("node16"))
//		{
//			perturRangeSet.add(new Integer(4+11));
//		}
//		if(nameList.contains("node17"))
//		{
//			if(!nameList.contains("node16"))
//			{
//				perturRangeSet.add(new Integer(4+12));
//			}
//		}
		
		
		/**
		 * for icrc
		 */
		// 添加输入变量
		perturRangeSet.add(new Integer(1));
		perturRangeSet.add(new Integer(2));
		perturRangeSet.add(new Integer(3));
		perturRangeSet.add(new Integer(4));
		
		// 添加辅助变量
		if(nameList.contains("node7"))
		{
			perturRangeSet.add(new Integer(4+1));
		}
		else if(nameList.contains("node8"))
		{
			perturRangeSet.add(new Integer(4+2));
			if(nameList.contains("node9"))
			{
				perturRangeSet.add(new Integer(4+3));
			}
			else
			{
				perturRangeSet.add(new Integer(4+4));
			}
		}
		if(nameList.contains("node15"))
		{
			perturRangeSet.add(new Integer(4+5));
			if(nameList.contains("node16"))
			{
				perturRangeSet.add(new Integer(4+9));
			}
			else
			{
				perturRangeSet.add(new Integer(4+10));
			}
		}
		if(nameList.contains("node11"))
		{
			perturRangeSet.add(new Integer(4+6));
			if(nameList.contains("node13"))
			{
				perturRangeSet.add(new Integer(4+8));
			}
			else
			{
				perturRangeSet.add(new Integer(4+7));
			}
		}
	}
	
	
	
	/**
	 *  初始化与变量关联的节点集合
	 * @param path
	 */
	private static int[][] setNodeSetCorrectedWithVari()
	{
		/**
		 *  for bessj
		 */
//		int[][] set = {{3,4,8,12,10,11,14,22,16,17,13,21},{6,7,8,12,16,17},
//				                              {3},{4},{6},{7},{8},
//				                              {12},{16},{13},{17},{10},
//				                              {11},{18},{19},{22},{14},
//		};
		
		/**
		 *  for expint
		 */
//		int[][] set = {{3,4,5,6,10,13,16,19,20,22,23,26},{3,4,7,8,9,10,13,15,16,26},
//										{3},{3},{4},{4},{4},{4},{4},
//										{6},{8},{9},{13},{15},{19},{22},{26},{26},
//										{10},{23},{16},{16}};
		
		/**
		 *  for ei
		 */
//		int [][] set={{3,4,5,6,7,8,11,15,19,20,21,22},
//							{3},{4},{5},{7},{15},
//							{11},{8},{19},{20},{21},{22},{6}
//		};
		
		/**
		 *  for julday
		 */
//		int [][] set={{7,8,11,12},{11,12},{3,4,5,6,11,12},
//				{4},{6},{5},{7},{8},{11},{12}
//		};
		
		/**
		 * for icrc
		 */
		int [][] set={{},{11,15},{7,8},{9,10,16,17,12,13},
				{7},{8},{9},{10},{15},
				{11},{12},{13},{16},{17}
		};
		
		return set;
	}


}
	